@dommaker/harness 1.2.3 → 1.4.0

package/src/cli/commands/sync-docs/project-reader.ts

@@ -5,9 +5,9 @@
 import * as fs from 'fs/promises';
 import { existsSync } from 'fs';
 import * as path from 'path';
-import { loadRawProjectConfig } from '../../../core/project-config-loader';
+import { loadRawProjectConfig, resolveContextFiles } from '../../../core/project-config-loader';
 import { detectSourceRoots } from '../../../utils/detect-source-roots';
-import { findTsSourceFiles, isTsSourceFile } from '../../../utils/file-walk';
+import { DEFAULT_SKIP_DIRS, findTsSourceFiles, isTsSourceFile } from '../../../utils/file-walk';
 
 export interface ModuleInfo {
   name: string;
@@ -65,28 +65,27 @@ export function formatScriptCommand(pm: 'pnpm' | 'yarn' | 'npm', name: string):
 
 /**
  * 获取需要 CONTEXT.md 的目录列表
+ *
+ * context_files 三态语义（工单 84）：enabled 且非空 → 配置目录；
+ * enabled 但无目标 → 工具流兜底回落自动探测（回落保留在调用方，不进访问器）；
+ * 未配置 → 空列表。
  */
 export async function getRequiredContextDirs(projectPath: string): Promise<string[]> {
-  try {
-    const config = loadRawProjectConfig(projectPath) ?? {};
-    const governance = config.governance as Record<string, unknown> | undefined;
-    const contextFiles = governance?.context_files as Record<string, unknown> | undefined;
-    if (contextFiles?.enabled) {
-      if (Array.isArray(contextFiles.required_dirs) && contextFiles.required_dirs.length > 0) {
-        return contextFiles.required_dirs as string[];
-      }
-      // Fallback: auto-discover from source roots
-      return detectSourceRoots(projectPath);
-    }
-  } catch {
-    // 配置不存在或无法解析
+  const resolution = resolveContextFiles(projectPath);
+  if (resolution.state === 'enabled') {
+    return resolution.dirs;
+  }
+  if (resolution.state === 'enabled-empty') {
+    // Fallback: auto-discover from source roots
+    return detectSourceRoots(projectPath);
   }
   return [];
 }
 
 /**
  * 获取源码扫描目录列表
- * 优先从 governance.context_files.required_dirs 读取，默认 ['src']
+ * 优先从 governance.context_files.required_dirs 读取；未配置或配置为空时
+ * 回落自动探测（detectSourceRoots），并非固定 ['src']
  */
 export async function getSourceDirs(projectPath: string): Promise<string[]> {
   const requiredDirs = await getRequiredContextDirs(projectPath);
@@ -108,8 +107,8 @@ export async function scanSourceModules(srcDir: string, projectPath: string): Pr
   }
 
   for (const entry of entries) {
-    // 跳过测试目录和非源码目录
-    if (entry === '__tests__' || entry === 'node_modules' || entry === 'dist') continue;
+    // 跳过依赖/旁测/构建产物目录（名单正本见 utils/file-walk）
+    if (DEFAULT_SKIP_DIRS.includes(entry)) continue;
 
     const entryPath = path.join(srcDir, entry);
     const stat = await fs.stat(entryPath);

package/src/cli/commands/update-user-model.ts

@@ -22,10 +22,12 @@ import * as path from 'path';
 import * as os from 'os';
 import {
   readTranscriptSessions,
+  type TranscriptFilter,
   extractCorrectionMatches,
   cleanCorrectionConcept,
   jaccardChinese,
 } from '../session-mining';
+import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
 
 export interface UpdateUserModelOptions {
   days?: number;    // 只处理最近 N 天（自然日，含今天）的会话；缺省不过滤（向后兼容）
@@ -51,7 +53,7 @@ interface ModelState {
 const STATE_FILE = path.join(os.homedir(), '.claude', 'user-model-state.json');
 const PROFILE_FILE = path.join(os.homedir(), '.claude', 'projects', '-root-projects', 'memory', 'user_profile.md');
 
-export async function updateUserModel(options: UpdateUserModelOptions): Promise<void> {
+export async function updateUserModel(options: UpdateUserModelOptions, io: CommandIO = processIO): Promise<CommandResult> {
   const transcriptDir = process.env.CLAUDE_TRANSCRIPTS_DIR
     || path.join(os.homedir(), '.claude', 'projects', '-root--claude');
 
@@ -61,8 +63,8 @@ export async function updateUserModel(options: UpdateUserModelOptions): Promise<
   // 2. Scan new data
   const newSessions = findNewSessions(transcriptDir, state.sessionsProcessed, options.days);
   if (newSessions.length === 0) {
-    console.log(chalk.gray('No new sessions to process'));
-    return;
+    log(io, chalk.gray('No new sessions to process'));
+    return { kind: 'skip', reason: '没有新会话可处理' };
   }
 
   // 3. Extract signals from new data
@@ -94,12 +96,13 @@ export async function updateUserModel(options: UpdateUserModelOptions): Promise<
 
   // 6. Output
   if (options.json) {
-    console.log(JSON.stringify({ newSessions: newSessions.length, changes }, null, 2));
-    return;
+    log(io, JSON.stringify({ newSessions: newSessions.length, changes }, null, 2));
+    return { kind: 'ok' };
   }
 
-  console.log(chalk.blue(`📊 Processed ${newSessions.length} new sessions\n`));
-  printChanges(changes, signals);
+  log(io, chalk.blue(`📊 Processed ${newSessions.length} new sessions\n`));
+  printChanges(changes, signals, io);
+  return { kind: 'ok' };
 }
 
 // ── State I/O ──
@@ -139,17 +142,20 @@ interface SimpleSession {
 }
 
 function findNewSessions(dir: string, processed: string[], days?: number): SimpleSession[] {
-  let sessions = readTranscriptSessions(dir)
-    .filter(s => !processed.includes(s.id));
+  // 过滤下推 seam（harness#112）：excludeIds 走文件名、since 走 stat，未命中不 parse
+  const filter: TranscriptFilter = { excludeIds: processed };
 
   // 「最近 N 天」：自然日窗口（含今天）。days<=0 视为不过滤，与缺省一致。
+  // date 是 mtime 的 UTC 日，date >= cutoff ⟺ mtimeMs >= cutoff 日 UTC 零点
   if (days !== undefined && days > 0) {
     const cutoff = new Date(Date.now() - (days - 1) * 86_400_000)
       .toISOString()
       .slice(0, 10);
-    sessions = sessions.filter(s => s.date >= cutoff);
+    filter.since = Date.parse(cutoff);
   }
 
+  const sessions = readTranscriptSessions(dir, filter);
+
   sessions.sort((a, b) => a.date.localeCompare(b.date));
 
   return sessions.map(s => ({
@@ -329,6 +335,8 @@ function applySignals(state: ModelState, signals: SessionSignals[], mergedConcep
   const now = new Date().toISOString().slice(0, 10);
 
   // Update patterns from merged concept clusters
+  // occurrences 唯一来源：mergedConcepts 聚合值（含 correction phrase 的 ×3 加权，
+  // 见 buildMergedConcepts）。不再叠加 per-session 原始 count —— 那是 #113 裁决的双计 bug。
   for (const [concept, agg] of Object.entries(mergedConcepts)) {
     if (!state.patterns[concept]) {
       state.patterns[concept] = {
@@ -344,26 +352,6 @@ function applySignals(state: ModelState, signals: SessionSignals[], mergedConcep
     p.trend = p.occurrences >= 5 ? 'stable' : 'rising';
   }
 
-  // Also track per-session concepts
-  for (const sig of signals) {
-    for (const [concept, count] of Object.entries(sig.concepts)) {
-      if (!state.patterns[concept]) {
-        state.patterns[concept] = {
-          firstSeen: now,
-          occurrences: 0,
-          sessions: [],
-          trend: 'new',
-          lastSeen: now,
-        };
-      }
-      const p = state.patterns[concept];
-      p.occurrences += count;
-      if (!p.sessions.includes(sig.sessionId)) p.sessions.push(sig.sessionId);
-      p.lastSeen = now;
-      p.trend = p.occurrences >= 5 ? 'stable' : 'rising';
-    }
-  }
-
   // Update lens weights from correction signals
   for (const sig of signals) {
     if (sig.correctionPhrases.length > 0) {
@@ -430,9 +418,9 @@ function updateProfile(state: ModelState): void {
 
 // ── Output ──
 
-function printChanges(changes: Change[], signals: SessionSignals[]): void {
+function printChanges(changes: Change[], signals: SessionSignals[], io: CommandIO): void {
   if (changes.length === 0) {
-    console.log(chalk.green('No significant changes detected'));
+    log(io, chalk.green('No significant changes detected'));
     return;
   }
 
@@ -443,31 +431,31 @@ function printChanges(changes: Change[], signals: SessionSignals[]): void {
   };
 
   if (byType.new_pattern.length > 0) {
-    console.log(chalk.yellow(`🌱 New patterns: ${byType.new_pattern.length}`));
+    log(io, chalk.yellow(`🌱 New patterns: ${byType.new_pattern.length}`));
     for (const c of byType.new_pattern.slice(0, 5)) {
-      console.log(chalk.gray(`   ${c.key}: ${c.detail}`));
+      log(io, chalk.gray(`   ${c.key}: ${c.detail}`));
     }
-    console.log();
+    log(io);
   }
 
   if (byType.rising.length > 0) {
-    console.log(chalk.green(`📈 Re-emerging: ${byType.rising.length}`));
+    log(io, chalk.green(`📈 Re-emerging: ${byType.rising.length}`));
     for (const c of byType.rising.slice(0, 5)) {
-      console.log(chalk.gray(`   ${c.key}: ${c.detail}`));
+      log(io, chalk.gray(`   ${c.key}: ${c.detail}`));
     }
-    console.log();
+    log(io);
   }
 
   if (byType.lens_shift.length > 0) {
-    console.log(chalk.cyan(`🎯 Lens shifts:`));
+    log(io, chalk.cyan(`🎯 Lens shifts:`));
     for (const c of byType.lens_shift) {
-      console.log(chalk.gray(`   ${c.key}: ${c.detail}`));
+      log(io, chalk.gray(`   ${c.key}: ${c.detail}`));
     }
-    console.log();
+    log(io);
   }
 
-  console.log(chalk.bold(`Total signals processed:`));
-  console.log(`  Sessions: ${signals.length}`);
-  console.log(`  Correction phrases: ${signals.reduce((s, sig) => s + sig.correctionPhrases.length, 0)}`);
-  console.log(`  Concepts extracted: ${signals.reduce((s, sig) => s + Object.keys(sig.concepts).length, 0)}`);
+  log(io, chalk.bold(`Total signals processed:`));
+  log(io, `  Sessions: ${signals.length}`);
+  log(io, `  Correction phrases: ${signals.reduce((s, sig) => s + sig.correctionPhrases.length, 0)}`);
+  log(io, `  Concepts extracted: ${signals.reduce((s, sig) => s + Object.keys(sig.concepts).length, 0)}`);
 }

package/src/cli/commands/validate.ts

@@ -10,6 +10,7 @@ import * as path from 'path';
 import * as yaml from 'js-yaml';
 import { CheckpointValidator } from '../../core/validators/checkpoint';
 import type { Checkpoint, CheckpointContext } from '../../types/checkpoint';
+import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
 
 export interface ValidateOptions {
   /** 检查点文件路径 */
@@ -28,13 +29,13 @@ const DEFAULT_CHECKPOINT_FILE = '.harness/checkpoints.yml';
 /**
  * 加载检查点配置
  */
-async function loadCheckpoints(filePath: string): Promise<Checkpoint[]> {
+async function loadCheckpoints(filePath: string, io: CommandIO): Promise<Checkpoint[]> {
   try {
     const content = await fs.readFile(filePath, 'utf-8');
     const data = yaml.load(content) as { checkpoints?: Checkpoint[] };
     return data.checkpoints || [];
   } catch (error) {
-    console.log(chalk.yellow(`⚠️  未找到检查点文件: ${filePath}`));
+    log(io, chalk.yellow(`⚠️  未找到检查点文件: ${filePath}`));
     return [];
   }
 }
@@ -42,23 +43,26 @@ async function loadCheckpoints(filePath: string): Promise<Checkpoint[]> {
 /**
  * 执行检查点验证
  */
-export async function validate(options: ValidateOptions): Promise<void> {
-  console.log(chalk.blue('🔍 验证检查点...'));
+export async function validate(
+  options: ValidateOptions,
+  io: CommandIO = processIO,
+): Promise<CommandResult> {
+  log(io, chalk.blue('🔍 验证检查点...'));
 
   const projectPath = options.projectPath || process.cwd();
   const checkpointFile = options.file || path.join(projectPath, DEFAULT_CHECKPOINT_FILE);
 
   // 加载检查点
-  const checkpoints = await loadCheckpoints(checkpointFile);
+  const checkpoints = await loadCheckpoints(checkpointFile, io);
 
   if (checkpoints.length === 0) {
-    console.log(chalk.gray('没有定义检查点，跳过验证'));
-    return;
+    log(io, chalk.gray('没有定义检查点，跳过验证'));
+    return { kind: 'skip', reason: `没有定义检查点: ${checkpointFile}` };
   }
 
-  console.log(chalk.gray(`检查点文件: ${checkpointFile}`));
-  console.log(chalk.gray(`检查点数量: ${checkpoints.length}`));
-  console.log();
+  log(io, chalk.gray(`检查点文件: ${checkpointFile}`));
+  log(io, chalk.gray(`检查点数量: ${checkpoints.length}`));
+  log(io);
 
   // 构建上下文
   const context: CheckpointContext = {
@@ -69,20 +73,22 @@ export async function validate(options: ValidateOptions): Promise<void> {
   // 执行验证
   const validator = CheckpointValidator.getInstance();
   const results = [];
+  const failedIds: string[] = [];
 
   for (const checkpoint of checkpoints) {
     const result = await validator.validate(checkpoint, context);
     results.push(result);
 
     if (result.passed) {
-      console.log(chalk.green(`✅ ${checkpoint.id}: 通过`));
+      log(io, chalk.green(`✅ ${checkpoint.id}: 通过`));
     } else {
-      console.log(chalk.red(`❌ ${checkpoint.id}: 失败`));
+      log(io, chalk.red(`❌ ${checkpoint.id}: 失败`));
       result.checks.forEach(check => {
         if (!check.passed) {
-          console.log(chalk.red(`   - ${check.checkId}: ${check.message || check.error}`));
+          log(io, chalk.red(`   - ${check.checkId}: ${check.message || check.error}`));
         }
       });
+      failedIds.push(checkpoint.id);
     }
   }
 
@@ -90,16 +96,16 @@ export async function validate(options: ValidateOptions): Promise<void> {
   const passed = results.filter(r => r.passed).length;
   const failed = results.filter(r => !r.passed).length;
 
-  console.log();
-  console.log(chalk.gray(`通过: ${passed}/${results.length}`));
+  log(io);
+  log(io, chalk.gray(`通过: ${passed}/${results.length}`));
 
   if (failed > 0) {
-    console.log(chalk.red(`\n🛑 ${failed} 个检查点未通过`));
+    log(io, chalk.red(`\n🛑 ${failed} 个检查点未通过`));
     // 工单 23：门控语义——检查点失败一律非零退出（此前仅 --strict 退出，钩子/CI 形同虚设）
-    process.exit(1);
-  } else {
-    console.log(chalk.green('\n✅ 所有检查点验证通过'));
+    return { kind: 'fail', reason: `${failed} 个检查点未通过: ${failedIds.join(', ')}` };
   }
+  log(io, chalk.green('\n✅ 所有检查点验证通过'));
+  return { kind: 'ok' };
 }
 
 /**
@@ -138,14 +144,14 @@ export const DEFAULT_CHECKPOINTS: Checkpoint[] = [
 /**
  * 创建示例检查点文件
  */
-export async function createExampleCheckpoint(projectPath: string): Promise<void> {
+export async function createExampleCheckpoint(projectPath: string, io: CommandIO = processIO): Promise<void> {
   const filePath = path.join(projectPath, DEFAULT_CHECKPOINT_FILE);
   const dir = path.dirname(filePath);
 
   // 如果已存在，不覆盖
   try {
     await fs.access(filePath);
-    console.log(chalk.gray(`checkpoints.yml 已存在，跳过`));
+    log(io, chalk.gray(`checkpoints.yml 已存在，跳过`));
     return;
   } catch {
     // 文件不存在，创建
@@ -156,7 +162,7 @@ export async function createExampleCheckpoint(projectPath: string): Promise<void
   const content = yaml.dump({ checkpoints: DEFAULT_CHECKPOINTS }, { indent: 2 });
   await fs.writeFile(filePath, content, 'utf-8');
 
-  console.log(chalk.green(`✅ 已创建示例检查点文件: ${filePath}`));
+  log(io, chalk.green(`✅ 已创建示例检查点文件: ${filePath}`));
 }
 
 /**
@@ -180,14 +186,14 @@ const DEFAULT_RESOLUTIONS = {
 /**
  * 创建示例 Resolutions 文件（RKB dogfood）
  */
-export async function createExampleResolutions(projectPath: string): Promise<void> {
+export async function createExampleResolutions(projectPath: string, io: CommandIO = processIO): Promise<void> {
   const harnessDir = path.join(projectPath, '.harness');
   const filePath = path.join(harnessDir, 'resolutions.json');
 
   // 如果已存在，不覆盖
   try {
     await fs.access(filePath);
-    console.log(chalk.gray(`resolutions.json 已存在，跳过`));
+    log(io, chalk.gray(`resolutions.json 已存在，跳过`));
     return;
   } catch {
     // 文件不存在，创建
@@ -198,5 +204,5 @@ export async function createExampleResolutions(projectPath: string): Promise<voi
   const content = JSON.stringify(DEFAULT_RESOLUTIONS, null, 2);
   await fs.writeFile(filePath, content, 'utf-8');
 
-  console.log(chalk.green(`✅ 已创建 Resolutions 文件: ${filePath}`));
+  log(io, chalk.green(`✅ 已创建 Resolutions 文件: ${filePath}`));
 }

package/src/cli/session-mining/__tests__/transcript.test.ts

@@ -0,0 +1,118 @@
+/**
+ * readTranscriptSessions 坏行/null 记录容错测试（harness#82）
+ *
+ * transcript 行可 parse 但值为 null（或提取异常）时，
+ * 与原逐行 catch 实现一致：该条跳过，不影响其余记录。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { readTranscriptSessions } from '../transcript';
+
+describe('readTranscriptSessions 坏行容错（harness#82）', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-transcript-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('null 行与坏行只丢该行，合法 turn 照常提取', () => {
+    const lines = [
+      JSON.stringify({ message: { role: 'user', content: 'hello' } }),
+      'null', // parse 合法但值为 null，原实现经逐行 catch 跳过
+      '{"broken',
+      JSON.stringify({ message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }),
+    ];
+    fs.writeFileSync(path.join(dir, 'session-a.jsonl'), lines.join('\n') + '\n', 'utf-8');
+
+    const sessions = readTranscriptSessions(dir);
+    expect(sessions).toHaveLength(1);
+    expect(sessions[0].turns.map(t => t.role)).toEqual(['user', 'assistant']);
+    expect(sessions[0].turns[1].content).toBe('hi');
+  });
+
+  it('目录不可读返回空数组', () => {
+    expect(readTranscriptSessions(path.join(dir, 'missing'))).toEqual([]);
+  });
+});
+
+describe('readTranscriptSessions 过滤（harness#112）', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-transcript-filter-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  function writeSession(name: string, text: string, mtime?: Date): void {
+    const p = path.join(dir, name);
+    fs.writeFileSync(
+      p,
+      JSON.stringify({ message: { role: 'user', content: text } }) + '\n',
+      'utf-8',
+    );
+    if (mtime) fs.utimesSync(p, mtime, mtime);
+  }
+
+  it('excludeIds：命中的会话不进结果（文件名级过滤，不 parse）', () => {
+    writeSession('session-a.jsonl', '甲会话内容');
+    writeSession('session-b.jsonl', '乙会话内容');
+
+    const sessions = readTranscriptSessions(dir, { excludeIds: ['session-a'] });
+    expect(sessions.map(s => s.id)).toEqual(['session-b']);
+  });
+
+  it('excludeIds 按截断 40 字符的会话 ID 匹配', () => {
+    const longName = 'a'.repeat(50);
+    writeSession(`${longName}.jsonl`, '长名会话内容');
+    writeSession('session-b.jsonl', '乙会话内容');
+
+    const sessions = readTranscriptSessions(dir, { excludeIds: [longName.slice(0, 40)] });
+    expect(sessions.map(s => s.id)).toEqual(['session-b']);
+  });
+
+  it('since：mtimeMs 早于窗口的文件不进结果（stat 级过滤，不 parse）', () => {
+    writeSession('old.jsonl', '旧会话内容', new Date(Date.now() - 30 * 86_400_000));
+    writeSession('recent.jsonl', '新会话内容');
+
+    const since = Date.now() - 7 * 86_400_000;
+    const sessions = readTranscriptSessions(dir, { since });
+    expect(sessions.map(s => s.id)).toEqual(['recent']);
+  });
+
+  it('since 边界含等于：mtimeMs == since 仍计入', () => {
+    const t = new Date('2026-08-01T12:00:00.000Z');
+    writeSession('edge.jsonl', '边界会话内容', t);
+
+    const sessions = readTranscriptSessions(dir, { since: t.getTime() });
+    expect(sessions.map(s => s.id)).toEqual(['edge']);
+  });
+
+  it('since 与 excludeIds 可叠加', () => {
+    writeSession('old.jsonl', '旧会话内容', new Date(Date.now() - 30 * 86_400_000));
+    writeSession('excluded.jsonl', '被排除会话');
+    writeSession('kept.jsonl', '保留会话内容');
+
+    const sessions = readTranscriptSessions(dir, {
+      since: Date.now() - 7 * 86_400_000,
+      excludeIds: ['excluded'],
+    });
+    expect(sessions.map(s => s.id)).toEqual(['kept']);
+  });
+
+  it('无 filter：全量读取（向后兼容）', () => {
+    writeSession('a.jsonl', '甲会话内容', new Date(Date.now() - 30 * 86_400_000));
+    writeSession('b.jsonl', '乙会话内容');
+
+    const sessions = readTranscriptSessions(dir);
+    expect(sessions).toHaveLength(2);
+  });
+});

package/src/cli/session-mining/transcript.ts

@@ -7,6 +7,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
+import { readJsonl } from '../../utils/jsonl';
 
 export interface MinedTurn {
   role: string;
@@ -41,8 +42,18 @@ function extractText(content: unknown): string {
  *
  * 不可读/损坏的行静默跳过（与原实现一致）。
  */
-export function readTranscriptSessions(dir: string): MinedSession[] {
+export interface TranscriptFilter {
+  /** 只读 mtimeMs >= since 的文件（stat 级过滤，命中即不 parse）；缺省不过滤 */
+  since?: number;
+  /** 按会话 ID（文件名去 .jsonl、截断 40 字符）排除（文件名级过滤，不 stat 不 parse）；缺省不排除 */
+  excludeIds?: string[];
+}
+
+export function readTranscriptSessions(dir: string, filter: TranscriptFilter = {}): MinedSession[] {
   const sessions: MinedSession[] = [];
+  const exclude = filter.excludeIds && filter.excludeIds.length > 0
+    ? new Set(filter.excludeIds)
+    : undefined;
 
   let files: string[];
   try {
@@ -53,6 +64,8 @@ export function readTranscriptSessions(dir: string): MinedSession[] {
 
   for (const file of files) {
     if (!file.endsWith('.jsonl')) continue;
+    const id = file.replace('.jsonl', '').slice(0, 40);
+    if (exclude?.has(id)) continue;
     const filePath = path.join(dir, file);
 
     let stat: fs.Stats;
@@ -61,21 +74,26 @@ export function readTranscriptSessions(dir: string): MinedSession[] {
     } catch {
       continue;
     }
+    if (filter.since !== undefined && stat.mtimeMs < filter.since) continue;
 
     const turns: MinedTurn[] = [];
     const toolCalls: string[] = [];
 
-    let content: string;
+    let records: Record<string, any>[];
     try {
-      content = fs.readFileSync(filePath, 'utf-8');
+      // 损坏行静默跳过（坏行策略 skip，与原实现一致，harness#82 走 jsonl 正本）；
+      // 外层 catch 兜文件不可读，沿用原「跳过该文件」语义
+      // 计数去向：豁免（harness#100）——读的是外部 Claude Code transcript（非 harness 写入面）。
+      // 影响方向如实：坏行使该会话少几条 turn，而 analyze-sessions 的候选按次数阈值筛
+      // （frequency>=4 / 跨会话>=2 / confidence=len/10）→ 只会少出候选，不会造出候选，且候选须人审；
+      // 告知需改 MinedSession 形状并波及 analyze-sessions/update-user-model 两个调用方，另票收口
+      records = readJsonl<Record<string, any>>(filePath, 'skip').records;
     } catch {
       continue;
     }
 
-    for (const line of content.split('\n')) {
-      if (!line.trim()) continue;
+    for (const entry of records) {
       try {
-        const entry = JSON.parse(line);
         const msg = entry.message;
         if (msg?.role && (msg.content || entry.type === 'user')) {
           turns.push({ role: msg.role, content: extractText(msg.content) });
@@ -88,13 +106,13 @@ export function readTranscriptSessions(dir: string): MinedSession[] {
           }
         }
       } catch {
-        // 损坏行跳过
+        // 单条记录提取异常跳过（原逐行 catch 语义：parse 已由 module skip，此处兜提取）
       }
     }
 
     if (turns.length > 0) {
       sessions.push({
-        id: file.replace('.jsonl', '').slice(0, 40),
+        id,
         date: stat.mtime.toISOString().slice(0, 10),
         mtimeMs: stat.mtimeMs,
         turns,

package/src/completion-checkers/CONTEXT.md

@@ -1,7 +1,7 @@
 # completion-checkers/
 
 ## 职责
-WU 收尾软观测三纯判定函数（T7-E1，studio#160）：tdd-chain 引用链 / phase-format subject 结构 / contract-presence 契约在场。纯函数，不碰文件系统与 git，commits 由调用方（studio completion-gates 第四段守卫，T7-E2）供给。
+提交集收尾软观测三纯判定函数：tdd-chain 引用链 / phase-format subject 结构 / contract-presence 契约在场。纯函数，不碰文件系统与 git，commits 由调用方（completion-gates 类守卫）供给。
 
 ## 核心导出
 - `verifyTddChain(commits, config)`（`tdd-chain.ts`）——实现 commit 须带 trailer `Tested-By: <sha>`（`TESTED_BY_RE` 写死）；被引 sha 须在本提交集内、位置在前、文件清单命中 test_globs；`Tests: none`（`TESTS_NONE_RE`）→ waiver；纯测试/纯非代码 commit 天然免检

package/src/completion-checkers/__tests__/contract-presence.test.ts

@@ -1,5 +1,5 @@
 /**
- * verifyContractPresence 测试（studio#160 验收：契约标记缺失 / 无表项 skip）
+ * verifyContractPresence 测试（契约标记缺失 / 无表项 skip）
  */
 
 import { verifyContractPresence } from '../contract-presence';

package/src/completion-checkers/__tests__/phase-format.test.ts

@@ -1,5 +1,5 @@
 /**
- * verifyPhaseFormat 测试（studio#160 验收：subject 不合规 / merge commit 违规）
+ * verifyPhaseFormat 测试（subject 不合规 / merge commit 违规）
  */
 
 import { verifyPhaseFormat } from '../phase-format';

package/src/completion-checkers/__tests__/tdd-chain.test.ts

@@ -1,5 +1,5 @@
 /**
- * verifyTddChain 测试（studio#160 验收：伪造引用三形态 / Tests: none waiver / 免检分类）
+ * verifyTddChain 测试（伪造引用三形态 / Tests: none waiver / 免检分类）
  */
 
 import { verifyTddChain } from '../tdd-chain';
@@ -34,7 +34,7 @@ describe('verifyTddChain', () => {
     const commits = [commit({ sha: sha(2), body: 'Tested-By: ' + sha(9) })];
     const result = verifyTddChain(commits);
     expect(result.verdict).toBe('violation');
-    expect(result.commits[0].reason).toContain('不在本 WU 提交集内');
+    expect(result.commits[0].reason).toContain('不在本提交集内');
   });
 
   it('伪造引用：被引 commit 位置在本 commit 之后 → violation', () => {

package/src/completion-checkers/index.ts

@@ -1,13 +1,13 @@
 /**
- * Completion Checkers（T7-E1，studio#160）
+ * Completion Checkers
  *
- * WU 收尾软观测三件套——纯判定函数库：
+ * 提交集收尾软观测三件套——纯判定函数库：
  * - verifyTddChain：实现 commit 的 Tested-By 引用链验证
  * - verifyPhaseFormat：phase(...) subject 结构验证
  * - verifyContractPresence：通用契约在场引擎
  *
  * 与 ConstraintCheck 闭环注册表无关：直接 export，不注册、不碰 checkers/index.ts。
- * 函数不碰文件系统与 git；commits 由调用方（studio 第四段守卫，T7-E2）供给。
+ * 函数不碰文件系统与 git；commits 由调用方（completion-gates 类守卫）供给。
  */
 
 export * from './types';

package/src/completion-checkers/phase-format.ts

@@ -1,5 +1,5 @@
 /**
- * phase-format：WU 提交 subject 的 phase 结构验证（Q4 定稿）
+ * phase-format：提交 subject 的 phase 结构验证（Q4 定稿）
  *
  * 协议（正则写死在函数里，不进配置）：
  * - 全部非 merge commit 的 subject 命中 `^phase\([a-z0-9-]+\):\s+\S`
@@ -32,7 +32,7 @@ export function verifyPhaseFormat(
 
   const verdicts: CommitVerdict[] = commits.map((commit) => {
     if (isMergeCommit(commit)) {
-      return { sha: commit.sha, verdict: 'violation', reason: 'WU 提交集内出现 merge commit' };
+      return { sha: commit.sha, verdict: 'violation', reason: '提交集内出现 merge commit' };
     }
     if (!PHASE_SUBJECT_RE.test(commit.subject)) {
       return { sha: commit.sha, verdict: 'violation', reason: `subject 不合规：${commit.subject}` };