@dommaker/harness 0.17.1 → 0.19.0

package/src/__tests__/clean-state-extra.test.ts

@@ -4,7 +4,7 @@
  * 目标：覆盖 autoCommit、detectBugs 完整流程、异常分支
  */
 
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
+import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
 import { CleanStateManager } from '../core/session/clean-state';
 import * as fs from 'fs';
 import * as path from 'path';

package/src/__tests__/constraint-doctor.test.ts

@@ -5,7 +5,7 @@
 import { describe, it, expect, beforeAll, afterAll, jest } from '@jest/globals';
 import { ConstraintDoctor } from '../monitoring/constraint-doctor';
 import type { TraceAnomaly } from '../types/trace';
-import type { LLMAdapter, Message, LLMOptions, SummarizeConfig } from '../llm/types';
+import type { LLMAdapter, Message, LLMOptions } from '../llm/types';
 import * as fs from 'fs';
 import * as path from 'path';
 

package/src/__tests__/doctor-extra.test.ts

@@ -5,25 +5,16 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { TraceCollector } from '../monitoring/traces';
-import { TraceAnalyzer } from '../monitoring/trace-analyzer';
 import { ConstraintDoctor, createDoctor } from '../monitoring/constraint-doctor';
 import type { ExecutionTrace, TraceAnomaly } from '../types/trace';
 
 describe('ConstraintDoctor', () => {
   let tempDir: string;
-  let collector: TraceCollector;
-  let analyzer: TraceAnalyzer;
   let doctor: ConstraintDoctor;
 
   beforeEach(() => {
     tempDir = path.join(os.tmpdir(), `harness-traces-${Date.now()}`);
     fs.mkdirSync(tempDir, { recursive: true });
-    collector = new TraceCollector({
-      traceFile: path.join(tempDir, 'execution.log'),
-      enabled: true,
-    });
-    analyzer = new TraceAnalyzer(collector);
     doctor = createDoctor();
   });
 

package/src/__tests__/effective-constraints.test.ts

@@ -85,6 +85,27 @@ constraints:
       expect(constraints.length).toBe(BUILTIN_TOTAL - SCENE_PROMPTS.length - 2);
     });
 
+    it('config.yml 禁用：custom 约束同样从生效集移除（retire 落 config.yml 的退役路径）', () => {
+      const dir = setupProject(
+        `
+constraints:
+  my_project_rule:
+    enabled: false
+`,
+        `
+custom_constraints:
+  my_project_rule:
+    level: iron_law
+    rule: MY RULE
+    message: 项目自定义
+`
+      );
+      const constraints = getEffectiveConstraints(dir);
+      const ids = constraints.map(c => c.id);
+
+      expect(ids).not.toContain('my_project_rule');
+    });
+
     it('preset: relaxed 裁剪生效集', () => {
       const dir = setupProject(`preset: relaxed\n`);
       const constraints = getEffectiveConstraints(dir);

package/src/__tests__/hooks-pipeline.test.ts

@@ -206,7 +206,7 @@ describe('HookPipeline', () => {
     registry.register(makeHook('enabled'));
     registry.register(makeHook('disabled', { enabled: false }));
 
-    const result = await pipeline.run('before', ctx);
+    await pipeline.run('before', ctx);
 
     expect(ctx.calls).toEqual(['enabled']);
     expect(ctx.calls).not.toContain('disabled');

package/src/__tests__/iron-laws.test.ts

@@ -82,6 +82,17 @@ describe('Constraint System', () => {
       expect(PROMPTS['no_skill_without_test'].appliesTo).toEqual(['agent-skill']);
       expect(PROMPTS['no_model_for_deterministic'].appliesTo).toEqual(['llm-app']);
     });
+
+    it('no_completion_without_verification 不硬编码具体命令示例（#25：口径由项目声明）', () => {
+      const law = IRON_LAWS['no_completion_without_verification'];
+      expect(law.promptInjection).not.toMatch(/npm test|npm run build/);
+      expect(law.description).not.toMatch(/npm test|npm run build/);
+      expect(law.promptInjection).not.toContain('完整');
+      expect(law.description).not.toContain('完整');
+      expect(law.promptInjection).toContain('项目声明的测试');
+      expect(law.description).toContain('项目声明的测试');
+      expect(law.promptInjection).toContain('不得凭记忆声称完成');
+    });
   });
 
   describe('注册表闭环', () => {

package/src/__tests__/passes-gate-extension.test.ts

@@ -6,7 +6,7 @@
 
 import { describe, it, expect, beforeEach } from '@jest/globals';
 import { PassesGate, createPassesGate } from '../core/validators/passes-gate';
-import type { PassesGateExtension, TaskTestResult } from '../types/passes-gate';
+import type { PassesGateExtension } from '../types/passes-gate';
 
 describe('PassesGate Extension', () => {
   let passesGate: PassesGate;
@@ -100,7 +100,7 @@ describe('PassesGate Extension', () => {
       const extension: PassesGateExtension = {
         name: 'puppeteer',
         description: 'Puppeteer E2E tests',
-        run: async (workDir) => ({
+        run: async (_workDir) => ({
           passed: true,
           command: 'puppeteer',
           output: 'E2E passed',
@@ -116,7 +116,7 @@ describe('PassesGate Extension', () => {
     it('扩展 run 方法应返回 TaskTestResult', async () => {
       const extension: PassesGateExtension = {
         name: 'mock',
-        run: async (workDir, task) => {
+        run: async (_workDir, _task) => {
           // 模拟测试运行
           return {
             passed: true,

package/src/__tests__/passes-gate-extra.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, it, expect, beforeAll, afterAll, beforeEach } from '@jest/globals';
 import { PassesGate, createPassesGate } from '../core/validators/passes-gate';
-import { mkdirSync, rmSync, writeFileSync, existsSync, mkdir } from 'fs';
+import { mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
 describe('PassesGate - 补充覆盖', () => {

package/src/__tests__/performance-analyzer.test.ts

@@ -6,7 +6,6 @@ import { PerformanceAnalyzer, createPerformanceAnalyzer } from '../monitoring/pe
 import { PerformanceCollector } from '../monitoring/performance-collector';
 import type { PerformanceTrace, PerformanceSummary } from '../types/performance';
 import * as fs from 'fs';
-import * as path from 'path';
 
 // Mock fs
 jest.mock('fs', () => ({
@@ -25,7 +24,6 @@ jest.mock('../monitoring/performance-collector', () => ({
 }));
 
 const mockFs = fs as jest.Mocked<typeof fs>;
-const MockPerformanceCollector = PerformanceCollector as jest.MockedClass<typeof PerformanceCollector>;
 
 describe('PerformanceAnalyzer', () => {
   let analyzer: PerformanceAnalyzer;

package/src/__tests__/traces.test.ts

@@ -7,7 +7,6 @@ import * as path from 'path';
 import * as os from 'os';
 import { TraceCollector } from '../monitoring/traces';
 import { TraceAnalyzer } from '../monitoring/trace-analyzer';
-import type { ExecutionTrace } from '../types/trace';
 
 describe('TraceCollector', () => {
   let tempDir: string;
@@ -175,7 +174,7 @@ describe('TraceCollector', () => {
   });
 
   test('should return 0 when backup dir does not exist', () => {
-    const result = collector.cleanupOldFiles(30);
+    collector.cleanupOldFiles(30);
     // Dir exists (created by constructor), so this won't hit line 259.
     // Create a collector with a path in non-existent dir to test that branch.
     const tmpRoot = path.join(os.tmpdir(), `harness-traces-nonexistent-${Date.now()}`);

package/src/architecture/cross-project-checker.ts

@@ -323,8 +323,8 @@ function isBreakingChange(change: ApiChange): boolean {
 
 function getDependents(project: string, config: CrossProjectConfig): string[] {
   return Object.entries(config.dependencies)
-    .filter(([_, deps]) => deps.includes(project))
-    .map(([name, _]) => name);
+    .filter(([, deps]) => deps.includes(project))
+    .map(([name]) => name);
 }
 
 interface ApiChange {

package/src/cli/commands/CONTEXT.md

@@ -6,7 +6,7 @@ CLI 子命令实现：24 个顶层命令 + constraints 治理子命令 report/re
 ## 核心导出(24 顶层命令)
 check / validate / passes-gate / init / report / status / spec / acceptance / performance / security / contract / review / command / sync-docs / knowledge / sdd / failure / posteval-plan / release / analyze-sessions / update-user-model / constraints / doc-freshness-check / spec-baseline-check
 
-`constraints` 下挂治理子命令：`constraints report`（使用统计 + 退役候选诊断 + 配置健康 + 注入漂移，`--export` 脱敏）、`constraints retire`（交互选择 + 人确认退役，config.yml retired 元数据 + KnowledgeStore 沉淀 + CLAUDE.md 注入段同步）。
+`constraints` 下挂治理子命令：`constraints report`（使用统计 + 退役候选诊断 + 配置健康 + 注入漂移，`--export` 脱敏）、`constraints retire`（交互选择 + 人确认退役；带 id 直达需显式 `--yes`（#24 人确认闸门），无 `--yes` 报错 + 非零退出码且不落盘；内置落 config.yml retired 元数据，custom 落 custom-constraints.yml 条目 retired 段（#82 D6 一处真相）+ KnowledgeStore 沉淀 + CLAUDE.md 注入段同步）。
 
 ## 依赖关系
 - 依赖 `src/core/constraints/` 约束引擎

package/src/cli/commands/__tests__/analyze-sessions.test.ts

@@ -0,0 +1,178 @@
+/**
+ * analyze-sessions 命令测试（O6）
+ *
+ * Seam：analyzeSessions(options) 公开入口。
+ * 隔离面：
+ *   - os.homedir → 测试临时目录（memory 规则库落 TEST_HOME）
+ *   - readTranscriptSessions → fixture 会话（extractCorrectionMatches/tokenize 等纯函数保持真实）
+ *   - CLAUDE_TRANSCRIPTS_DIR → 测试临时目录（决定 transcripts 目录是否存在）
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { analyzeSessions } from '../analyze-sessions';
+import { readTranscriptSessions, type MinedSession } from '../../session-mining';
+
+const TEST_HOME = '/tmp/harness-analyze-test-home';
+
+jest.mock('os', () => ({
+  ...jest.requireActual('os'),
+  homedir: () => '/tmp/harness-analyze-test-home',
+}));
+
+jest.mock('../../session-mining', () => ({
+  ...jest.requireActual('../../session-mining'),
+  readTranscriptSessions: jest.fn(),
+}));
+
+jest.mock('chalk', () => {
+  const id = (s: string) => s;
+  const chalkFn = Object.assign(id, {
+    gray: id,
+    blue: id,
+    green: id,
+    yellow: id,
+    cyan: id,
+    bold: id,
+    red: id,
+  });
+  return {
+    __esModule: true,
+    default: chalkFn,
+    gray: id,
+    blue: id,
+    green: id,
+    yellow: id,
+    cyan: id,
+    bold: id,
+    red: id,
+  };
+});
+
+const mockReadTranscriptSessions = readTranscriptSessions as jest.MockedFunction<
+  typeof readTranscriptSessions
+>;
+
+const TRANSCRIPTS_DIR = path.join(TEST_HOME, 'transcripts');
+
+function mkSession(partial: Partial<MinedSession> = {}): MinedSession {
+  return {
+    id: 'session-1',
+    date: '2026-08-15',
+    mtimeMs: Date.now(),
+    turns: [
+      { role: 'user', content: '我不是说要用中文吗' },
+      { role: 'assistant', content: '收到，改用中文' },
+    ],
+    toolCalls: [],
+    ...partial,
+  };
+}
+
+function lastJsonOutput(consoleSpy: jest.SpyInstance): Record<string, unknown> {
+  const jsonLine = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+  return JSON.parse(jsonLine);
+}
+
+describe('analyze-sessions command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.rmSync(TEST_HOME, { recursive: true, force: true });
+    fs.mkdirSync(path.join(TEST_HOME, '.claude', 'projects', '-root-projects', 'memory'), { recursive: true });
+    fs.mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
+    process.env.CLAUDE_TRANSCRIPTS_DIR = TRANSCRIPTS_DIR;
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    delete process.env.CLAUDE_TRANSCRIPTS_DIR;
+  });
+
+  test('transcripts 目录不存在：提示 No transcripts directory found', async () => {
+    process.env.CLAUDE_TRANSCRIPTS_DIR = path.join(TEST_HOME, 'missing-dir');
+
+    await analyzeSessions({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No transcripts directory found'));
+    expect(mockReadTranscriptSessions).not.toHaveBeenCalled();
+  });
+
+  test('窗口内无会话：提示 No sessions found（默认最近 7 天）', async () => {
+    mockReadTranscriptSessions.mockReturnValue([
+      mkSession({ id: 'old', mtimeMs: Date.now() - 30 * 86_400_000 }),
+    ]);
+
+    await analyzeSessions({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No sessions found in the last 7 days'));
+  });
+
+  test('--days 1：只统计最近 1 天（mtimeMs 窗口过滤）', async () => {
+    mockReadTranscriptSessions.mockReturnValue([
+      mkSession({ id: 'today' }),
+      mkSession({ id: 'two-days-ago', mtimeMs: Date.now() - 2 * 86_400_000 }),
+    ]);
+
+    await analyzeSessions({ days: 1 });
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Analyzing 1 sessions (last 1 days)'));
+  });
+
+  test('缺省 --days：窗口为 7 天，两天前会话仍计入', async () => {
+    mockReadTranscriptSessions.mockReturnValue([
+      mkSession({ id: 'today' }),
+      mkSession({ id: 'two-days-ago', mtimeMs: Date.now() - 2 * 86_400_000 }),
+    ]);
+
+    await analyzeSessions({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Analyzing 2 sessions (last 7 days)'));
+  });
+
+  test('--json：纠正句跨 3 会话聚合为 correction 候选', async () => {
+    mockReadTranscriptSessions.mockReturnValue([
+      mkSession({ id: 's1' }),
+      mkSession({ id: 's2' }),
+      mkSession({ id: 's3' }),
+    ]);
+
+    await analyzeSessions({ json: true });
+
+    const output = lastJsonOutput(consoleSpy);
+    expect(output.sessions).toBe(3);
+    expect(output.corrections).toBe(3);
+    expect(output.candidates).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          source: 'correction',
+          frequency: 3,
+          pattern: '我不是说',
+        }),
+      ]),
+    );
+  });
+
+  test('--json：跨会话重复概念产出 ngram 候选', async () => {
+    const ngramText = { role: 'user', content: '数据库迁移方案的详细讨论' };
+    mockReadTranscriptSessions.mockReturnValue([
+      mkSession({
+        id: 's1',
+        turns: [ngramText, { role: 'assistant', content: '好的' }],
+      }),
+      mkSession({
+        id: 's2',
+        turns: [ngramText, { role: 'assistant', content: '明白' }],
+      }),
+    ]);
+
+    await analyzeSessions({ json: true });
+
+    const output = lastJsonOutput(consoleSpy);
+    const ngramCandidates = (output.candidates as Array<{ source: string }>)
+      .filter(c => c.source === 'ngram');
+    expect(ngramCandidates.length).toBeGreaterThan(0);
+  });
+});

package/src/cli/commands/__tests__/check-drift.test.ts

@@ -82,7 +82,7 @@ describe('check 命令注入漂移警告', () => {
     expect(output).toContain('⚠️⚠️');
     expect(output).toContain('agent 上下文中的规则与已安装 harness 版本不一致');
     expect(output).toContain('0.0.1-old');
-    expect(output).toContain('npx harness init');
+    expect(output).toContain('npx @dommaker/harness init');
     // 不阻断：检查仍通过、未调用 process.exit
     expect(output).toContain('约束检查通过');
     expect(exitSpy).not.toHaveBeenCalled();

package/src/cli/commands/__tests__/check-skip-output.test.ts

@@ -5,9 +5,7 @@
  */
 
 import { check } from '../check';
-import * as fs from 'fs';
 import { constraintChecker } from '../../../core/constraints/checker';
-import { ProjectConfigLoader } from '../../../core/project-config-loader';
 
 // Mock fs
 jest.mock('fs', () => ({

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

@@ -3,7 +3,7 @@
  */
 
 import { executeCommand } from '../command';
-import { createCommandGate, getCommandRiskLevel, DEFAULT_COMMAND_BLACKLIST } from '../../../gates';
+import { createCommandGate, getCommandRiskLevel } from '../../../gates';
 
 jest.mock('../../../gates', () => ({
   createCommandGate: jest.fn(),

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

@@ -290,7 +290,7 @@ describe('constraintsReport 注入漂移小节（ADR-0001 决策 7）', () => {
     expect(output).toContain('0.0.1-old');
     expect(output).toContain(`缺失: ${originalLine}`);
     expect(output).toContain(`多余: ${editedLine}`);
-    expect(output).toContain('npx harness init');
+    expect(output).toContain('npx @dommaker/harness init');
   });
 
   it('重复章节：输出重复章节提示', async () => {

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

@@ -40,6 +40,24 @@ function readConfig(root: string): any {
   return yaml.load(fs.readFileSync(path.join(root, '.harness', 'config.yml'), 'utf-8'));
 }
 
+const CUSTOM_YML = `
+custom_constraints:
+  my_custom_rule:
+    level: iron_law
+    rule: 禁止引入 X
+    message: X 已由平台能力替代
+    promptInjection: 禁止引入 X
+`;
+
+function writeCustom(root: string, yml: string): void {
+  fs.mkdirSync(path.join(root, '.harness'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.harness', 'custom-constraints.yml'), yml, 'utf-8');
+}
+
+function readCustom(root: string): any {
+  return yaml.load(fs.readFileSync(path.join(root, '.harness', 'custom-constraints.yml'), 'utf-8'));
+}
+
 let logSpy: jest.SpyInstance;
 
 beforeEach(() => {
@@ -184,12 +202,121 @@ describe('retireConstraint 执行逻辑', () => {
     retireConstraint(root, 'capability_sync', { now: FIXED_NOW });
     expect(getEffectiveConstraints(root).some(c => c.id === 'capability_sync')).toBe(false);
   });
+
+  it('custom 约束退役：落 custom-constraints.yml retired 段（不写 config.yml），生效集与注入段移除', () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    const before = renderConstraintsSection(getEffectiveConstraints(root), '0.0.0-test');
+    expect(before).toContain('**my_custom_rule**');
+    fs.writeFileSync(path.join(root, 'CLAUDE.md'), `# 项目\n\n## Governance Rules\n${before}\n其他内容\n`, 'utf-8');
+
+    const result = retireConstraint(root, 'my_custom_rule', { reason: '作用对象已从代码库消失', now: FIXED_NOW });
+
+    expect(result.status).toBe('retired');
+    expect(result.landing).toBe('custom-constraints.yml');
+    expect(result.claudeMdSynced).toBe(true);
+    // config.yml 不产生该 id 段
+    expect(fs.existsSync(path.join(root, '.harness', 'config.yml'))).toBe(false);
+    // yml 保留规则原文 + retired 元数据
+    const custom = readCustom(root).custom_constraints.my_custom_rule;
+    expect(custom.rule).toBe('禁止引入 X');
+    expect(custom.promptInjection).toBe('禁止引入 X');
+    expect(custom.retired.at).toBe(FIXED_NOW.toISOString());
+    expect(custom.retired.reason).toBe('作用对象已从代码库消失');
+    // 生效集移除
+    expect(getEffectiveConstraints(root).some(c => c.id === 'my_custom_rule')).toBe(false);
+    // 注入段同步移除
+    const after = fs.readFileSync(path.join(root, 'CLAUDE.md'), 'utf-8');
+    expect(after).not.toContain('**my_custom_rule**');
+    expect(after).toContain('其他内容');
+    // 打印的恢复提示指向 yml
+    printRetireResult(result);
+    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    expect(output).toContain('custom_constraints.my_custom_rule.retired');
+  });
+
+  it('custom 重复退役：yml 已带 retired → already_retired，不覆盖原元数据', () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    const first = retireConstraint(root, 'my_custom_rule', { reason: '第一次', now: FIXED_NOW });
+    expect(first.status).toBe('retired');
+
+    const later = new Date('2026-08-09T00:00:00.000Z');
+    const second = retireConstraint(root, 'my_custom_rule', { reason: '第二次', now: later });
+    expect(second.status).toBe('already_retired');
+
+    const custom = readCustom(root).custom_constraints.my_custom_rule;
+    expect(custom.retired.at).toBe(FIXED_NOW.toISOString());
+    expect(custom.retired.reason).toBe('第一次');
+  });
+
+  it('custom 历史落点（config.yml enabled:false）仍判定 already_retired', () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    fs.writeFileSync(path.join(root, '.harness', 'config.yml'), 'constraints:\n  my_custom_rule:\n    enabled: false\n', 'utf-8');
+    const result = retireConstraint(root, 'my_custom_rule', { now: FIXED_NOW });
+    expect(result.status).toBe('already_retired');
+  });
+
+  it('custom 退役 KnowledgeStore 记录包含 promptInjection（规则原文完整）', () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    const result = retireConstraint(root, 'my_custom_rule', { reason: '由新机制覆盖', now: FIXED_NOW });
+    expect(result.status).toBe('retired');
+
+    const store = new FileKnowledgeStore({ baseDir: path.join(root, '.harness', 'knowledge') });
+    const entry = store.get('constraint-retired-my_custom_rule');
+    expect(entry).toBeDefined();
+    expect(entry!.content).toContain('禁止引入 X');
+    expect(entry!.content).toContain('promptInjection: 禁止引入 X');
+  });
+
+  it('custom 恢复：删除 yml retired 段后回到生效集', () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    retireConstraint(root, 'my_custom_rule', { now: FIXED_NOW });
+    expect(getEffectiveConstraints(root).some(c => c.id === 'my_custom_rule')).toBe(false);
+
+    const custom = readCustom(root);
+    delete custom.custom_constraints.my_custom_rule.retired;
+    fs.writeFileSync(path.join(root, '.harness', 'custom-constraints.yml'), yaml.dump(custom), 'utf-8');
+
+    expect(getEffectiveConstraints(root).some(c => c.id === 'my_custom_rule')).toBe(true);
+  });
 });
 
 describe('constraintsRetire 非交互直达', () => {
-  it('iron 直达退役时打印额外警示', async () => {
+  let originalExitCode: typeof process.exitCode;
+
+  beforeEach(() => {
+    originalExitCode = process.exitCode;
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    process.exitCode = originalExitCode;
+  });
+
+  it('无 --yes 直达：报错 + 非零退出码 + 不落盘任何文件（#24 人确认闸门）', async () => {
     const root = makeTmpProject();
-    await constraintsRetire('docs_freshness', { projectPath: root, reason: '直接退役' });
+    const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      await constraintsRetire('docs_freshness', { projectPath: root, reason: '直接退役' });
+
+      const output = errSpy.mock.calls.map(c => String(c[0])).join('\n');
+      expect(output).toContain('--yes');
+      expect(output).toContain('交互');
+      expect(process.exitCode).toBe(1);
+      // 无副作用：任何文件都不落盘
+      expect(fs.existsSync(path.join(root, '.harness'))).toBe(false);
+    } finally {
+      errSpy.mockRestore();
+    }
+  });
+
+  it('--yes 直达 iron 退役：打印额外警示并落盘', async () => {
+    const root = makeTmpProject();
+    await constraintsRetire('docs_freshness', { projectPath: root, reason: '直接退役', yes: true });
 
     const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
     expect(output).toContain('Iron Law');
@@ -199,9 +326,21 @@ describe('constraintsRetire 非交互直达', () => {
     expect(config.constraints.docs_freshness.enabled).toBe(false);
   });
 
-  it('未知 id 直达：明确提示', async () => {
+  it('--yes 直达非 iron（guideline）退役：不打印 iron 警示并落盘', async () => {
     const root = makeTmpProject();
-    await constraintsRetire('ghost', { projectPath: root });
+    await constraintsRetire('no_hardcoded_credentials', { projectPath: root, reason: '直接退役', yes: true });
+
+    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    expect(output).not.toContain('Iron Law');
+    expect(output).toContain('已退役');
+
+    const config = readConfig(root);
+    expect(config.constraints.no_hardcoded_credentials.enabled).toBe(false);
+  });
+
+  it('--yes 直达未知 id：明确提示', async () => {
+    const root = makeTmpProject();
+    await constraintsRetire('ghost', { projectPath: root, yes: true });
     const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
     expect(output).toContain('约束不存在');
   });
@@ -264,6 +403,28 @@ describe('runRetireInteractive 交互流程（注入 IO 流）', () => {
     expect(config.constraints.no_hardcoded_credentials.retired.reason).toBe('误报太多');
   });
 
+  it('无候选 → 手动输入 custom id → 确认执行 → 落 custom-constraints.yml', async () => {
+    const root = makeTmpProject();
+    writeCustom(root, CUSTOM_YML);
+    // 所有 check 约束给少量健康数据（低于一切候选阈值）
+    const healthy = getEffectiveConstraints(root)
+      .filter(c => c.kind === 'check')
+      .flatMap(c => [
+        { constraintId: c.id, result: 'pass' as const },
+        { constraintId: c.id, result: 'pass' as const, timestamp: 1700000001000 },
+        { constraintId: c.id, result: 'fail' as const, timestamp: 1700000002000 },
+      ]);
+    writeTraces(root, healthy);
+
+    const io = makeIo(['my_custom_rule', '作用对象消失', 'y']);
+    await runRetireInteractive(root, io);
+    io.done();
+
+    const custom = readCustom(root).custom_constraints.my_custom_rule;
+    expect(custom.retired.reason).toBe('作用对象消失');
+    expect(fs.existsSync(path.join(root, '.harness', 'config.yml'))).toBe(false);
+  });
+
   it('无候选 → 手动输入未知 id → 提示不存在并取消', async () => {
     const root = makeTmpProject();
     const healthy = getEffectiveConstraints(root)

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

@@ -13,7 +13,6 @@ jest.mock('../../../failure/recorder');
 
 describe('failure CLI commands', () => {
   const tempDir = path.join(process.cwd(), 'temp-test-failure-cli');
-  const logFilePath = path.join(tempDir, '.harness', 'failures', 'failures.log');
   let consoleSpy: jest.SpyInstance;
   let consoleErrorSpy: jest.SpyInstance;
   let mockRecorderInstance: {