@dommaker/harness 1.2.3 → 1.4.0

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

@@ -3,6 +3,7 @@
  */
 
 import { validate, createExampleCheckpoint, createExampleResolutions } from '../validate';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 import { CheckpointValidator } from '../../../core/validators/checkpoint';
 import * as yaml from 'js-yaml';
@@ -42,25 +43,22 @@ const MockCheckpointValidator = CheckpointValidator as jest.Mocked<typeof Checkp
 const mockYaml = yaml as jest.Mocked<typeof yaml>;
 
 describe('validate command', () => {
-  let consoleSpy: jest.SpyInstance;
+  let io: CapturingIO;
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    process.exitCode = 0;
-  });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    process.exitCode = 0;
+    io = captureIO();
+    jest.clearAllMocks();
   });
 
   describe('validate', () => {
     it('应该跳过无检查点的情况', async () => {
       mockFs.readFile.mockRejectedValue(new Error('file not found'));
       
-      await validate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('没有定义检查点'));
+      const result = await validate({}, io);
+
+      expect(io.outText()).toContain('没有定义检查点');
+      expect(result).toEqual({ kind: 'skip', reason: expect.stringContaining('没有定义检查点') });
     });
 
     it('应该通过所有检查点', async () => {
@@ -76,8 +74,10 @@ describe('validate command', () => {
       };
       (MockCheckpointValidator.getInstance as jest.Mock).mockReturnValue(mockValidator);
 
-      await validate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('所有检查点验证通过'));
+      const result = await validate({}, io);
+
+      expect(io.outText()).toContain('所有检查点验证通过');
+      expect(result).toEqual({ kind: 'ok' });
     });
 
     it('应该显示失败的检查点', async () => {
@@ -97,12 +97,11 @@ describe('validate command', () => {
       (MockCheckpointValidator.getInstance as jest.Mock).mockReturnValue(mockValidator);
 
       // 工单 23：检查点失败一律 exit 1（门控语义）
-      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
 
-      await validate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('失败'));
-      expect(mockExit).toHaveBeenCalledWith(1);
-      mockExit.mockRestore();
+      const result = await validate({}, io);
+
+      expect(io.outText()).toContain('失败');
+      expect(result).toEqual({ kind: 'fail', reason: '1 个检查点未通过: test-1' });
     });
 
     it('应该在严格模式下退出', async () => {
@@ -121,11 +120,10 @@ describe('validate command', () => {
       };
       (MockCheckpointValidator.getInstance as jest.Mock).mockReturnValue(mockValidator);
 
-      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+      const result = await validate({ strict: true }, io);
 
-      await validate({ strict: true });
-      expect(mockExit).toHaveBeenCalledWith(1);
-      mockExit.mockRestore();
+      // 工单 23 语义：--strict 与否都是 fail；退出码映射在 bin
+      expect(result).toEqual({ kind: 'fail', reason: '1 个检查点未通过: test-1' });
     });
   });
 
@@ -136,20 +134,20 @@ describe('validate command', () => {
       mockFs.writeFile.mockResolvedValue(undefined);
       mockYaml.dump.mockReturnValue('yaml content');
 
-      await createExampleCheckpoint('/project');
+      await createExampleCheckpoint('/project', io);
       
       expect(mockFs.mkdir).toHaveBeenCalled();
       expect(mockFs.writeFile).toHaveBeenCalled();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已创建示例检查点'));
+      expect(io.outText()).toContain('已创建示例检查点');
     });
 
     it('已存在时不覆盖', async () => {
       mockFs.access.mockResolvedValue(undefined);
 
-      await createExampleCheckpoint('/project');
+      await createExampleCheckpoint('/project', io);
 
       expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('checkpoints.yml 已存在，跳过'));
+      expect(io.outText()).toContain('checkpoints.yml 已存在，跳过');
     });
   });
 
@@ -159,20 +157,20 @@ describe('validate command', () => {
       mockFs.mkdir.mockResolvedValue(undefined);
       mockFs.writeFile.mockResolvedValue(undefined);
 
-      await createExampleResolutions('/project');
+      await createExampleResolutions('/project', io);
 
       expect(mockFs.mkdir).toHaveBeenCalled();
       expect(mockFs.writeFile).toHaveBeenCalled();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已创建 Resolutions 文件'));
+      expect(io.outText()).toContain('已创建 Resolutions 文件');
     });
 
     it('已存在时不覆盖', async () => {
       mockFs.access.mockResolvedValue(undefined);
 
-      await createExampleResolutions('/project');
+      await createExampleResolutions('/project', io);
 
       expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('resolutions.json 已存在，跳过'));
+      expect(io.outText()).toContain('resolutions.json 已存在，跳过');
     });
   });
 });

package/src/cli/commands/acceptance.ts

@@ -8,6 +8,8 @@ import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { SpecAcceptanceGate } from '../../gates/acceptance';
+import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
+
 
 export interface AcceptanceOptions {
   /** 任务 ID */
@@ -25,8 +27,11 @@ export interface AcceptanceOptions {
 /**
  * 执行验收门控
  */
-export async function acceptance(options: AcceptanceOptions): Promise<void> {
-  console.log(chalk.blue('📋 验收标准门控检查...'));
+export async function acceptance(
+  options: AcceptanceOptions,
+  io: CommandIO = processIO,
+): Promise<CommandResult> {
+  log(io, chalk.blue('📋 验收标准门控检查...'));
 
   const projectPath = options.projectPath || process.cwd();
 
@@ -47,36 +52,40 @@ export async function acceptance(options: AcceptanceOptions): Promise<void> {
     const result = await gate.check(context as any);
 
     if (result.passed) {
-      console.log();
-      console.log(chalk.green('✅ 验收标准检查通过'));
+      log(io);
+      log(io, chalk.green('✅ 验收标准检查通过'));
       if (result.details) {
-        console.log(chalk.gray(`   通过项: ${result.details.checkedCriteria ?? 0}`));
-        console.log(chalk.gray(`   总项数: ${result.details.totalCriteria ?? 0}`));
+        log(io, chalk.gray(`   通过项: ${result.details.checkedCriteria ?? 0}`));
+        log(io, chalk.gray(`   总项数: ${result.details.totalCriteria ?? 0}`));
       }
     } else {
-      console.log();
-      console.log(chalk.red('❌ 验收标准检查失败'));
-      console.log(chalk.red(`   ${result.message}`));
+      log(io);
+      log(io, chalk.red('❌ 验收标准检查失败'));
+      log(io, chalk.red(`   ${result.message}`));
       if (result.details?.uncheckedCriteria) {
         (result.details.uncheckedCriteria as string[]).forEach((criteria: string) => {
-          console.log(chalk.red(`   - ${criteria}`));
+          log(io, chalk.red(`   - ${criteria}`));
         });
       }
-      process.exit(1);
+      return { kind: 'fail', reason: `acceptance gate denied: ${result.message}` };
     }
+    return { kind: 'ok' };
   } catch (error: any) {
-    console.log();
-    console.log(chalk.red('❌ 验收标准检查出错'));
-    console.log(chalk.red(`   ${error.message}`));
-    process.exit(1);
+    log(io);
+    log(io, chalk.red('❌ 验收标准检查出错'));
+    log(io, chalk.red(`   ${error.message}`));
+    return { kind: 'fail', reason: `acceptance gate error: ${error.message}` };
   }
 }
 
 /**
  * 列出所有任务及其验收标准
  */
-export async function listAcceptanceCriteria(options: AcceptanceOptions): Promise<void> {
-  console.log(chalk.blue('📋 任务验收标准列表...\n'));
+export async function listAcceptanceCriteria(
+  options: AcceptanceOptions,
+  io: CommandIO = processIO,
+): Promise<CommandResult> {
+  log(io, chalk.blue('📋 任务验收标准列表...\n'));
 
   const projectPath = options.projectPath || process.cwd();
   const tasksPath = options.tasksPath || path.join(projectPath, 'tasks.yml');
@@ -87,25 +96,27 @@ export async function listAcceptanceCriteria(options: AcceptanceOptions): Promis
     const tasks = yaml.load(content) as any;
 
     if (!tasks || typeof tasks !== 'object') {
-      console.log(chalk.yellow('⚠️  未找到任务定义'));
-      return;
+      log(io, chalk.yellow('⚠️  未找到任务定义'));
+      return { kind: 'skip', reason: `未找到任务定义: ${tasksPath}` };
     }
 
     for (const [taskId, task] of Object.entries(tasks)) {
       if (typeof task === 'object' && task !== null) {
-        console.log(chalk.cyan(`${taskId}:`));
+        log(io, chalk.cyan(`${taskId}:`));
         const taskObj = task as any;
         if (taskObj.acceptanceCriteria) {
           taskObj.acceptanceCriteria.forEach((criteria: string, i: number) => {
-            console.log(chalk.gray(`  ${i + 1}. ${criteria}`));
+            log(io, chalk.gray(`  ${i + 1}. ${criteria}`));
           });
         } else {
-          console.log(chalk.gray('  (无验收标准)'));
+          log(io, chalk.gray('  (无验收标准)'));
         }
-        console.log();
+        log(io);
       }
     }
+    return { kind: 'ok' };
   } catch (error: any) {
-    console.log(chalk.red(`❌ 读取 tasks.yml 失败: ${error.message}`));
+    log(io, chalk.red(`❌ 读取 tasks.yml 失败: ${error.message}`));
+    return { kind: 'skip', reason: `读取 tasks.yml 失败: ${error.message}` };
   }
 }

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

@@ -28,6 +28,7 @@ import {
   hasSemanticContent,
   STOP_WORDS,
 } from '../session-mining';
+import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
 
 export interface AnalyzeSessionsOptions {
   days?: number;
@@ -52,26 +53,25 @@ interface PatternCandidate {
 
 // ── Main ──
 
-export async function analyzeSessions(options: AnalyzeSessionsOptions): Promise<void> {
+export async function analyzeSessions(options: AnalyzeSessionsOptions, io: CommandIO = processIO): Promise<CommandResult> {
   const transcriptDir = process.env.CLAUDE_TRANSCRIPTS_DIR
     || path.join(os.homedir(), '.claude', 'projects', '-root--claude');
   const memoryDir = path.join(os.homedir(), '.claude', 'projects', '-root-projects', 'memory');
   const days = options.days || 7;
 
   if (!fs.existsSync(transcriptDir)) {
-    console.log(chalk.yellow('No transcripts directory found'));
-    return;
+    log(io, chalk.yellow('No transcripts directory found'));
+    return { kind: 'skip', reason: `会话记录目录不存在: ${transcriptDir}` };
   }
 
-  // 1. Scan transcripts（按修改时间过滤 + 倒序）
+  // 1. Scan transcripts（since 下推 seam（harness#112）：stat 级过滤，窗口外不 parse；倒序）
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
-  const sessions = readTranscriptSessions(transcriptDir)
-    .filter(s => s.mtimeMs >= cutoff)
+  const sessions = readTranscriptSessions(transcriptDir, { since: cutoff })
     .sort((a, b) => b.date.localeCompare(a.date));
 
   if (sessions.length === 0) {
-    console.log(chalk.yellow(`No sessions found in the last ${days} days`));
-    return;
+    log(io, chalk.yellow(`No sessions found in the last ${days} days`));
+    return { kind: 'skip', reason: `最近 ${days} 天没有会话` };
   }
 
   // 2. Extract corrections + N-grams
@@ -86,14 +86,15 @@ export async function analyzeSessions(options: AnalyzeSessionsOptions): Promise<
 
   // 5. Output
   if (options.json) {
-    console.log(JSON.stringify({ sessions: sessions.length, corrections: corrections.length, candidates }, null, 2));
-    return;
+    log(io, JSON.stringify({ sessions: sessions.length, corrections: corrections.length, candidates }, null, 2));
+    return { kind: 'ok' };
   }
 
-  console.log(chalk.blue(`🔍 Analyzing ${sessions.length} sessions (last ${days} days)...\n`));
+  log(io, chalk.blue(`🔍 Analyzing ${sessions.length} sessions (last ${days} days)...\n`));
 
-  printCorrectionSummary(corrections);
-  printCandidates(candidates);
+  printCorrectionSummary(corrections, io);
+  printCandidates(candidates, io);
+  return { kind: 'ok' };
 }
 
 // ── Correction Extraction ──
@@ -301,34 +302,34 @@ function extractConcept(sentences: string[]): string {
 
 // ── Output ──
 
-function printCorrectionSummary(corrections: Correction[]): void {
+function printCorrectionSummary(corrections: Correction[], io: CommandIO): void {
   if (corrections.length === 0) {
-    console.log(chalk.green('No correction patterns found'));
+    log(io, chalk.green('No correction patterns found'));
     return;
   }
 
-  console.log(chalk.yellow(`📢 ${corrections.length} correction signals detected\n`));
+  log(io, chalk.yellow(`📢 ${corrections.length} correction signals detected\n`));
 }
 
-function printCandidates(candidates: PatternCandidate[]): void {
+function printCandidates(candidates: PatternCandidate[], io: CommandIO): void {
   if (candidates.length === 0) {
-    console.log(chalk.green('✅ No new pattern candidates — all recurring concepts already have rules\n'));
+    log(io, chalk.green('✅ No new pattern candidates — all recurring concepts already have rules\n'));
     return;
   }
 
-  console.log(chalk.bold('🔔 Pattern Candidates (suggested rules)\n'));
+  log(io, chalk.bold('🔔 Pattern Candidates (suggested rules)\n'));
 
   const topK = candidates.slice(0, 10);
   for (const c of topK) {
     const icon = c.source === 'correction' ? '🔴' : '🟡';
     const confBar = '█'.repeat(Math.round(c.confidence * 10)) + '░'.repeat(10 - Math.round(c.confidence * 10));
-    console.log(chalk.bold(`${icon} ${c.pattern}`));
-    console.log(chalk.gray(`   Source: ${c.source} | Freq: ${c.frequency} | Sessions: ${c.sessions.length} | Confidence: ${confBar}`));
-    console.log(chalk.cyan(`   → Rule: ${c.suggestedRule}`));
-    console.log();
+    log(io, chalk.bold(`${icon} ${c.pattern}`));
+    log(io, chalk.gray(`   Source: ${c.source} | Freq: ${c.frequency} | Sessions: ${c.sessions.length} | Confidence: ${confBar}`));
+    log(io, chalk.cyan(`   → Rule: ${c.suggestedRule}`));
+    log(io);
   }
 
   if (candidates.length > 10) {
-    console.log(chalk.gray(`... and ${candidates.length - 10} more candidates. Run with --json for full list.`));
+    log(io, chalk.gray(`... and ${candidates.length - 10} more candidates. Run with --json for full list.`));
   }
 }

package/src/cli/commands/check.ts

@@ -4,18 +4,25 @@
  * 检查约束是否满足（check 层：Iron Laws / Guidelines；prompt 层仅注入不检查）
  * 工单 23：触发条件与证据检测迁至 core/constraints/context-builder
  * ADR-0001：约束集统一走 getMergedConstraintsConfig 生效集链路（preset/config 禁用/custom/scenes）
+ * harness#88：本命令是 trace 记录器的组合根——core 不上行依赖 monitoring，
+ * 真实收集器在此经构造参数接线
  */
 
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
-import { constraintChecker } from '../../core/constraints/checker';
+import { ConstraintChecker } from '../../core/constraints/checker';
 import { IRON_LAWS, GUIDELINES, PROMPTS } from '../../core/constraints/definitions';
 import { getMergedConstraintsConfig } from '../../core/effective-constraints';
 import { buildConstraintContext } from '../../core/constraints/context-builder';
+import { createGitEvidence, type GitEvidence } from '../../core/constraints/git-evidence';
 import { detectInjectionDrift } from '../../core/constraints/injection-drift';
+import { GOVERNANCE_HEADING } from '../../core/constraints/injection-writer';
+import { getTraceCollector } from '../../monitoring/traces';
+import { countJsonlLines } from '../../utils/jsonl';
 import { DEFAULT_TRACE_FILE } from '../../types/trace';
 import type { ConstraintTrigger } from '../../types/constraint';
+import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
 
 export interface CheckOptions {
   /** 预设名称 */
@@ -26,14 +33,24 @@ export interface CheckOptions {
   trigger?: ConstraintTrigger;
   /** 项目路径 */
   projectPath?: string;
+  /**
+   * git 证据 adapter（非 CLI flag；#87）
+   *
+   * 缺省 = 本 run 独占一份真 git 证据。注入则与调用方共用同一证据快照，
+   * 测试据此断言"同一 run 内每条 git 命令至多执行一次"。
+   */
+  evidence?: GitEvidence;
 }
 
 /**
  * 执行约束检查
  */
-export async function check(options: CheckOptions): Promise<void> {
-  console.log(chalk.blue('🔍 检查约束...'));
-  console.log(chalk.gray(`预设: ${options.preset}`));
+export async function check(
+  options: CheckOptions,
+  io: CommandIO = processIO,
+): Promise<CommandResult> {
+  log(io, chalk.blue('🔍 检查约束...'));
+  log(io, chalk.gray(`预设: ${options.preset}`));
 
   try {
     const projectPath = options.projectPath || process.cwd();
@@ -43,33 +60,38 @@ export async function check(options: CheckOptions): Promise<void> {
     // 项目自定义配置优先于 CLI 预设），优先级规则收在 getMergedConstraintsConfig 一处。
     const merged = getMergedConstraintsConfig(projectPath, { preset: options.preset });
     if (merged.custom.length > 0) {
-      console.log(chalk.gray(`自定义约束: ${merged.custom.length} 条`));
+      log(io, chalk.gray(`自定义约束: ${merged.custom.length} 条`));
     }
     if (merged.disabled.length > 0) {
-      console.log(chalk.gray(`已禁用约束: ${merged.disabled.join(', ')}`));
+      log(io, chalk.gray(`已禁用约束: ${merged.disabled.join(', ')}`));
     }
     const unknownIds = merged.unknownIds ?? [];
     if (unknownIds.length > 0) {
-      console.log(chalk.yellow(`⚠️  配置中存在未知约束 id（已忽略，可清理）: ${unknownIds.join(', ')}`));
+      log(io, chalk.yellow(`⚠️  配置中存在未知约束 id（已忽略，可清理）: ${unknownIds.join(', ')}`));
     }
 
     // 构建上下文（工单 23：触发条件与证据检测收敛至 core/constraints/context-builder）
+    // #87：一次 run 一份 git 证据——context-builder 与 checker 层共用同一实例
+    const evidence = options.evidence ?? createGitEvidence(projectPath);
     const context = await buildConstraintContext({
       projectPath: options.projectPath,
       staged: options.staged,
       trigger: options.trigger,
+      evidence,
     });
     const changedFiles = context.changedFiles ?? [];
     if (changedFiles.length > 0) {
-      console.log(chalk.gray(`变更文件: ${changedFiles.length} 个`));
+      log(io, chalk.gray(`变更文件: ${changedFiles.length} 个`));
     }
-    console.log(chalk.gray(`触发条件: ${[context.operation, ...(context.extraTriggers ?? [])].join(', ')}`));
+    log(io, chalk.gray(`触发条件: ${[context.operation, ...(context.extraTriggers ?? [])].join(', ')}`));
 
-    // 执行三层检查（per-request 传 customConfig，避免单例状态污染）
-    const result = await constraintChecker.checkConstraints(context, merged);
+    // 执行三层检查（per-request 传 customConfig，避免单例状态污染；证据同 run 同源）
+    // trace 记录器经构造参数接线（harness#88）：一次命令一个 checker 实例
+    const checker = new ConstraintChecker(getTraceCollector());
+    const result = await checker.checkConstraints(context, merged, evidence);
 
     // 输出结果
-    console.log();
+    log(io);
 
     // skipped（约定未采用/证据未接线）单独列示，不进 pass/fail 统计（ADR-0001）
     const skippedResults = [
@@ -81,39 +103,42 @@ export async function check(options: CheckOptions): Promise<void> {
     const evaluatedIronLaws = result.ironLaws.filter(r => !r.skipped);
     const ironLawViolations = evaluatedIronLaws.filter(r => !r.satisfied);
     if (ironLawViolations.length === 0 && evaluatedIronLaws.length > 0) {
-      console.log(chalk.green(`✅ 铁律: 全部通过 (${evaluatedIronLaws.length} 条)`));
+      log(io, chalk.green(`✅ 铁律: 全部通过 (${evaluatedIronLaws.length} 条)`));
     } else if (ironLawViolations.length > 0) {
-      console.log(chalk.red(`❌ 铁律违规: ${ironLawViolations.length} 条`));
+      log(io, chalk.red(`❌ 铁律违规: ${ironLawViolations.length} 条`));
       ironLawViolations.forEach(r => {
         if (r.constraint) {
-          console.log(chalk.red(`   - ${r.constraint.id}: ${r.constraint.message}`));
-          console.log(chalk.red(`     ${r.constraint.rule}`));
+          log(io, chalk.red(`   - ${r.constraint.id}: ${r.constraint.message}`));
+          log(io, chalk.red(`     ${r.constraint.rule}`));
         }
       });
-      console.log();
-      console.log(chalk.red('🛑 铁律检查失败，请修复后再提交'));
-      process.exit(1);
+      log(io);
+      log(io, chalk.red('🛑 铁律检查失败，请修复后再提交'));
+      return {
+        kind: 'fail',
+        reason: `iron law violated: ${ironLawViolations.map(r => r.constraint?.id ?? 'unknown').join(', ')}`,
+      };
     }
 
     // Guidelines
     if (result.warningCount > 0) {
-      console.log(chalk.yellow(`⚠️  指导原则警告: ${result.warningCount} 条`));
+      log(io, chalk.yellow(`⚠️  指导原则警告: ${result.warningCount} 条`));
       result.guidelines.filter(r => !r.satisfied).forEach(r => {
         if (r.constraint) {
-          console.log(chalk.yellow(`   - ${r.constraint.id}: ${r.constraint.message}`));
+          log(io, chalk.yellow(`   - ${r.constraint.id}: ${r.constraint.message}`));
         }
       });
     } else if (result.guidelines.length > 0) {
       const evaluatedGuidelines = result.guidelines.filter(r => !r.skipped);
       const passedGuidelines = evaluatedGuidelines.filter(r => r.satisfied).length;
-      console.log(chalk.green(`✅ 指导原则: ${passedGuidelines}/${evaluatedGuidelines.length} 通过`));
+      log(io, chalk.green(`✅ 指导原则: ${passedGuidelines}/${evaluatedGuidelines.length} 通过`));
     }
 
     // Skipped：约定未采用 / 证据未接线，未评估（不计通过/失败）
     if (skippedResults.length > 0) {
-      console.log(chalk.gray(`⏭️  跳过评估: ${skippedResults.length} 条（约定未采用或证据未接线，不计通过/失败）`));
+      log(io, chalk.gray(`⏭️  跳过评估: ${skippedResults.length} 条（约定未采用或证据未接线，不计通过/失败）`));
       skippedResults.forEach(r => {
-        console.log(chalk.gray(`   - ${r.id}`));
+        log(io, chalk.gray(`   - ${r.id}`));
       });
     }
 
@@ -122,38 +147,39 @@ export async function check(options: CheckOptions): Promise<void> {
     try {
       const drift = detectInjectionDrift(projectPath);
       if (drift.hasDrift) {
-        console.log();
-        console.log(chalk.yellow(`⚠️  检测到 ${drift.injectionFile ?? '治理文档'} 约束注入漂移（仅警告，不阻断）:`));
+        log(io);
+        log(io, chalk.yellow(`⚠️  检测到 ${drift.injectionFile ?? '治理文档'} 约束注入漂移（仅警告，不阻断）:`));
         if (drift.versionDrift) {
-          console.log(chalk.yellow(`   ⚠️⚠️ 注入段版本 (${drift.versionDrift.actual}) ≠ 已安装 harness 版本 (${drift.versionDrift.expected})：agent 上下文中的规则与已安装 harness 版本不一致`));
+          log(io, chalk.yellow(`   ⚠️⚠️ 注入段版本 (${drift.versionDrift.actual}) ≠ 已安装 harness 版本 (${drift.versionDrift.expected})：agent 上下文中的规则与已安装 harness 版本不一致`));
         }
         if (drift.contentDrift) {
-          console.log(chalk.yellow(`   内容漂移: 缺失 ${drift.contentDrift.missing.length} 条 / 多余 ${drift.contentDrift.extra.length} 条（条目级差异见 harness constraints report）`));
+          log(io, chalk.yellow(`   内容漂移: 缺失 ${drift.contentDrift.missing.length} 条 / 多余 ${drift.contentDrift.extra.length} 条（条目级差异见 harness constraints report）`));
         }
         if (drift.duplicateHeading) {
-          console.log(chalk.yellow('   检测到重复的 "## Governance Rules" 章节'));
+          log(io, chalk.yellow(`   检测到重复的 "${GOVERNANCE_HEADING}" 章节`));
         }
-        console.log(chalk.yellow(`   修复: ${drift.fixHint}`));
+        log(io, chalk.yellow(`   修复: ${drift.fixHint}`));
       }
     } catch {
       // 漂移检测失败不影响 check 结果
     }
 
-    console.log();
-    console.log(chalk.green('✅ 约束检查通过'));
+    log(io);
+    log(io, chalk.green('✅ 约束检查通过'));
 
     // 智能提示
     const hint = await getSmartHint(projectPath);
     if (hint) {
-      console.log();
-      console.log(chalk.gray('────────────────────────────────────'));
-      console.log(hint);
-      console.log(chalk.gray('────────────────────────────────────'));
+      log(io);
+      log(io, chalk.gray('────────────────────────────────────'));
+      log(io, hint);
+      log(io, chalk.gray('────────────────────────────────────'));
     }
+    return { kind: 'ok' };
   } catch (error) {
-    console.log();
-    console.log(chalk.red(`❌ 约束检查异常: ${error instanceof Error ? error.message : String(error)}`));
-    process.exit(1);
+    log(io);
+    log(io, chalk.red(`❌ 约束检查异常: ${error instanceof Error ? error.message : String(error)}`));
+    return { kind: 'fail', reason: `check error: ${error instanceof Error ? error.message : String(error)}` };
   }
 }
 
@@ -163,17 +189,12 @@ export async function check(options: CheckOptions): Promise<void> {
 async function getSmartHint(projectPath: string): Promise<string | null> {
   const tracesPath = path.join(projectPath, DEFAULT_TRACE_FILE);
   const statePath = path.join(projectPath, '.harness', '.state.json');
-  
-  // 检查 trace 文件是否存在
-  if (!fs.existsSync(tracesPath)) {
+
+  // 只数非空行数（含坏行），零 parse——原语义不变，走 jsonl 正本（harness#82）
+  const traceCount = countJsonlLines(tracesPath);
+  if (traceCount === 0) {
     return null;
   }
-  
-  // 读取 trace 记录数
-  const tracesContent = fs.readFileSync(tracesPath, 'utf-8');
-  const lines = tracesContent.trim().split('\n').filter(Boolean);
-  const traceCount = lines.length;
-  
   // 读取状态
   let state: { 
     shownHints?: string[];
@@ -206,33 +227,35 @@ async function getSmartHint(projectPath: string): Promise<string | null> {
 /**
  * 列出所有约束
  */
-export function listLaws(): void {
-  console.log(chalk.blue('\n📜 所有约束:\n'));
+/** optionRoutes 一律以 (options) 调用；--list 不消费检查选项，形参仅占位 */
+export function listLaws(_options: Partial<CheckOptions> = {}, io: CommandIO = processIO): CommandResult {
+  log(io, chalk.blue('\n📜 所有约束:\n'));
 
   // Iron Laws
-  console.log(chalk.red('🔴 铁律 (Iron Laws) - 绝对禁止，无例外:\n'));
+  log(io, chalk.red('🔴 铁律 (Iron Laws) - 绝对禁止，无例外:\n'));
   Object.values(IRON_LAWS).forEach(constraint => {
-    console.log(chalk.red(`  ${constraint.id}`));
-    console.log(chalk.gray(`    ${constraint.rule}`));
-    console.log(chalk.gray(`    ${constraint.message}`));
-    console.log();
+    log(io, chalk.red(`  ${constraint.id}`));
+    log(io, chalk.gray(`    ${constraint.rule}`));
+    log(io, chalk.gray(`    ${constraint.message}`));
+    log(io);
   });
 
   // Guidelines
-  console.log(chalk.yellow('🟡 指导原则 (Guidelines) - 优先建议，违背发警告但不阻止:\n'));
+  log(io, chalk.yellow('🟡 指导原则 (Guidelines) - 优先建议，违背发警告但不阻止:\n'));
   Object.values(GUIDELINES).forEach(constraint => {
-    console.log(chalk.yellow(`  ${constraint.id}`));
-    console.log(chalk.gray(`    ${constraint.rule}`));
-    console.log(chalk.gray(`    ${constraint.message}`));
-    console.log();
+    log(io, chalk.yellow(`  ${constraint.id}`));
+    log(io, chalk.gray(`    ${constraint.rule}`));
+    log(io, chalk.gray(`    ${constraint.message}`));
+    log(io);
   });
 
   // Prompts（ADR-0001：纯注入层，不执行检查）
-  console.log(chalk.blue('🔵 提示 (Prompts) - 纯文本注入，不参与检查:\n'));
+  log(io, chalk.blue('🔵 提示 (Prompts) - 纯文本注入，不参与检查:\n'));
   Object.values(PROMPTS).forEach(constraint => {
-    console.log(chalk.blue(`  ${constraint.id}`));
-    console.log(chalk.gray(`    ${constraint.rule}`));
-    console.log(chalk.gray(`    ${constraint.message}`));
-    console.log();
+    log(io, chalk.blue(`  ${constraint.id}`));
+    log(io, chalk.gray(`    ${constraint.rule}`));
+    log(io, chalk.gray(`    ${constraint.message}`));
+    log(io);
   });
+  return { kind: 'ok' };
 }