kld-sdd 2.6.15 → 2.6.16

package/templates/git-hooks/pre-push

@@ -0,0 +1,57 @@
+#!/bin/sh
+# KLD SDD Pre-Push Hook
+# 远程引用 spec 仓 skywalk-sdd/git-hooks/ 下的 .cjs 脚本
+# 兼容单仓库/多仓库/单仓mono布局
+# marker: KLD SDD quality gate
+
+# 从 hook 所在目录推算 git 根目录
+hook_dir="$(cd "$(dirname "$0")" && pwd)"
+git_dir="$(dirname "$hook_dir")"
+git_root="$(dirname "$git_dir")"
+
+hooks_dir=""
+
+# 方法1: git config sdd.specPath（多仓布局：spec 是独立 clone）
+spec_path=$(git config --local sdd.specPath 2>/dev/null)
+if [ -n "$spec_path" ] && [ -d "$spec_path/skywalk-sdd/git-hooks" ]; then
+  hooks_dir="$spec_path/skywalk-sdd/git-hooks"
+fi
+
+# 方法2: .sdd-spec-root（单仓 mono 布局：skywalk-sdd 在 spec 包裹包子目录内）
+if [ -z "$hooks_dir" ] && [ -f "$git_root/.sdd-spec-root" ]; then
+  spec_rel=$(cat "$git_root/.sdd-spec-root" | head -1 | tr -d '[:space:]')
+  if [ -n "$spec_rel" ] && [ -d "$git_root/$spec_rel/skywalk-sdd/git-hooks" ]; then
+    hooks_dir="$git_root/$spec_rel/skywalk-sdd/git-hooks"
+  fi
+fi
+
+# 方法3: 从 git 根向上搜索 skywalk-sdd/git-hooks（spec 仓本身或父级）
+if [ -z "$hooks_dir" ]; then
+  search_dir="$git_root"
+  while [ "$search_dir" != "/" ] && [ "$search_dir" != "" ]; do
+    if [ -d "$search_dir/skywalk-sdd/git-hooks" ]; then
+      hooks_dir="$search_dir/skywalk-sdd/git-hooks"
+      break
+    fi
+    search_dir="$(dirname "$search_dir")"
+  done
+fi
+
+if [ -z "$hooks_dir" ]; then
+  echo "[SDD] 未找到 spec 仓的 skywalk-sdd/git-hooks 目录，跳过 pre-push 检查"
+  exit 0
+fi
+
+echo "[SDD] 执行推送前检查..."
+
+# 1. doctor 质量门禁检查
+if [ -f "$hooks_dir/pre-push-sdd-check.cjs" ]; then
+  node "$hooks_dir/pre-push-sdd-check.cjs" --project="$git_root" "$@" || exit 1
+fi
+
+# 2. 代码-spec 一致性检查（推送前更严格）
+if [ -f "$hooks_dir/pre-push-consistency-check.cjs" ]; then
+  node "$hooks_dir/pre-push-consistency-check.cjs" --project="$git_root" "$@" || exit 1
+fi
+
+echo "[SDD] ✅ 所有 pre-push 检查通过"

package/templates/git-hooks/pre-push-consistency-check.cjs

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * pre-push-consistency-check.cjs
+ *
+ * Pre-push 门禁：检查活跃变更的 Spec 一致性校验报告。
+ * 与 pre-commit-consistency-check.cjs 类似，但更严格：
+ *   - confidence=low → 阻止推送
+ *   - 缺少报告 → 警告（默认放行）；strict 模式下阻止推送
+ *
+ * 用法: node pre-push-consistency-check.cjs --project=<project-root> [--change=<change-name>]
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function readArg(name) {
+  const prefix = `--${name}=`;
+  const found = process.argv.find(arg => arg.startsWith(prefix));
+  return found ? found.slice(prefix.length) : '';
+}
+
+function hasFlag(name) {
+  return process.argv.includes(`--${name}`);
+}
+
+/**
+ * 从 .sdd-spec-root 文件读取 spec 包裹包相对路径（单仓 mono 布局）
+ */
+function resolveSpecRoot(projectRoot) {
+  // 1. 检查 .sdd-spec-root（单仓 mono 模式）
+  const hintPath = path.join(projectRoot, '.sdd-spec-root');
+  if (fs.existsSync(hintPath)) {
+    const rel = fs.readFileSync(hintPath, 'utf8').trim();
+    if (rel) {
+      const specAbs = path.resolve(projectRoot, rel);
+      if (fs.existsSync(specAbs)) {
+        return specAbs;
+      }
+    }
+  }
+
+  // 2. 查找 *-sdd-specs 子目录（多仓工作区模式）
+  const entries = fs.existsSync(projectRoot) ? fs.readdirSync(projectRoot) : [];
+  for (const name of entries) {
+    if (/-sdd-specs$/i.test(name)) {
+      const candidate = path.join(projectRoot, name);
+      if (fs.statSync(candidate).isDirectory() && fs.existsSync(path.join(candidate, 'openspec'))) {
+        return candidate;
+      }
+    }
+  }
+
+  // 3. 项目根本身就是 spec 仓
+  if (fs.existsSync(path.join(projectRoot, 'openspec', 'changes'))) {
+    return projectRoot;
+  }
+
+  return null;
+}
+
+/**
+ * 发现活跃变更列表
+ */
+function discoverActiveChanges(specRoot, explicitChange) {
+  if (explicitChange) {
+    return [explicitChange];
+  }
+
+  const changesDir = path.join(specRoot, 'openspec', 'changes');
+  if (!fs.existsSync(changesDir)) {
+    return [];
+  }
+
+  return fs.readdirSync(changesDir)
+    .filter(name => {
+      const fullPath = path.join(changesDir, name);
+      return fs.statSync(fullPath).isDirectory()
+        && !name.startsWith('.')
+        && name !== 'archive';
+    });
+}
+
+/**
+ * 查找变更的一致性报告 JSON
+ */
+function findConsistencyReport(specRoot, changeName) {
+  const patterns = [
+    'consistency-report-result.json',
+    'consistency-report-self-review-result.json',
+  ];
+
+  for (const pattern of patterns) {
+    const reportPath = path.join(specRoot, 'openspec', 'changes', changeName, pattern);
+    if (fs.existsSync(reportPath)) {
+      return reportPath;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 解析一致性报告，返回置信度
+ */
+function parseReport(reportPath) {
+  try {
+    const content = fs.readFileSync(reportPath, 'utf8');
+    const data = JSON.parse(content);
+    return {
+      confidence: (data.confidence || '').toLowerCase(),
+      overallResult: (data.overallResult || '').toLowerCase(),
+      changeName: data.changeName || '',
+      reportPath,
+    };
+  } catch (err) {
+    return { confidence: '', overallResult: '', changeName: '', reportPath, parseError: err.message };
+  }
+}
+
+function main() {
+  const projectRoot = path.resolve(readArg('project') || process.env.SDD_PROJECT || process.cwd());
+  const explicitChange = readArg('change') || process.env.SDD_CHANGE || process.env.OPENSPEC_CHANGE || '';
+  const strictMode = hasFlag('strict') || process.env.SDD_STRICT_CONSISTENCY === '1';
+  const looseMode = hasFlag('no-strict') || process.env.SDD_LOOSE_CONSISTENCY === '1';
+
+  const specRoot = resolveSpecRoot(projectRoot);
+  if (!specRoot) {
+    console.log('SDD consistency-check (pre-push): 未找到 spec 仓库，跳过一致性校验');
+    return;
+  }
+
+  const changes = discoverActiveChanges(specRoot, explicitChange);
+  if (changes.length === 0) {
+    console.log('SDD consistency-check (pre-push): 无活跃变更，跳过一致性校验');
+    return;
+  }
+
+  const blockers = [];
+  const missing = [];
+  const passed = [];
+
+  for (const changeName of changes) {
+    const reportPath = findConsistencyReport(specRoot, changeName);
+    if (!reportPath) {
+      missing.push(changeName);
+      continue;
+    }
+
+    const report = parseReport(reportPath);
+    if (report.parseError) {
+      console.warn(`SDD consistency-check (pre-push): ⚠️  ${changeName} 报告解析失败: ${report.parseError}`);
+      missing.push(changeName);
+      continue;
+    }
+
+    if (report.confidence === 'low' || report.overallResult === 'fail') {
+      blockers.push({ changeName, report });
+    } else {
+      passed.push({ changeName, report });
+    }
+  }
+
+  // 输出摘要
+  if (passed.length > 0) {
+    for (const item of passed) {
+      console.log(`SDD consistency-check (pre-push): ✅ ${item.changeName} 置信度=${item.report.confidence}`);
+    }
+  }
+
+  if (missing.length > 0) {
+    console.warn(`SDD consistency-check (pre-push): ⚠️  以下变更缺少一致性校验报告:`);
+    for (const name of missing) {
+      console.warn(`  - ${name}`);
+    }
+    if (strictMode && !looseMode) {
+      console.error('SDD consistency-check (pre-push): ❌ strict 模式已启用，缺少报告的变更不允许推送。');
+      console.error('请先执行 opsx-consistency-check 生成报告，或使用 --no-verify 跳过（不推荐）。');
+      process.exit(1);
+    }
+    console.warn('  → 推送已放行，建议尽快执行 opsx-consistency-check');
+  }
+
+  if (blockers.length > 0) {
+    console.error(`SDD consistency-check (pre-push): ❌ 以下变更的一致性校验未通过（confidence=low），阻止推送:`);
+    for (const item of blockers) {
+      console.error(`  - ${item.changeName} (confidence=${item.report.confidence}, result=${item.report.overallResult})`);
+      console.error(`    报告路径: ${item.report.reportPath}`);
+    }
+    console.error('');
+    console.error('请修复不一致项后重新执行 opsx-consistency-check，或使用 --no-verify 跳过（不推荐）。');
+    process.exit(1);
+  }
+}
+
+main();

package/templates/hooks/codebuddy/hooks/hook-gate-core.cjs

@@ -0,0 +1,369 @@
+/**
+ * Shared SDD hook gate utilities for Claude and CodeBuddy adapters.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_ENV_KEYS = {
+  claude: 'CLAUDE_PROJECT_DIR',
+  codebuddy: 'CODEBUDDY_PROJECT_DIR',
+};
+
+function readStdin() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function parseHookInput(raw, options = {}) {
+  const { strict = false } = options;
+  if (!raw || !String(raw).trim()) {
+    if (strict) {
+      return { ok: false, error: 'stdin 为空，缺少 hook 输入 JSON' };
+    }
+    return { ok: true, input: {} };
+  }
+  try {
+    return { ok: true, input: JSON.parse(raw) };
+  } catch {
+    if (strict) {
+      return { ok: false, error: 'stdin 不是合法 JSON，无法解析 hook 输入' };
+    }
+    return { ok: true, input: {} };
+  }
+}
+
+function normalizeHookInput(input) {
+  const normalized = { ...(input || {}) };
+  normalized.tool_name = String(
+    normalized.tool_name || normalized.toolName || ''
+  );
+  normalized.tool_input = normalized.tool_input != null
+    ? normalized.tool_input
+    : (normalized.toolInput != null ? normalized.toolInput : {});
+  normalized.tool_response = normalized.tool_response != null
+    ? normalized.tool_response
+    : (normalized.toolResponse != null ? normalized.toolResponse : {});
+  return normalized;
+}
+
+function resolveSkywalkDir(dir) {
+  const root = path.resolve(dir || '.');
+  const direct = path.join(root, 'skywalk-sdd');
+  if (
+    fs.existsSync(path.join(direct, 'log.cjs'))
+    || fs.existsSync(path.join(direct, 'log.js'))
+  ) {
+    return direct;
+  }
+  const hintFile = path.join(root, '.sdd-spec-root');
+  if (fs.existsSync(hintFile)) {
+    const rel = String(fs.readFileSync(hintFile, 'utf8') || '')
+      .trim()
+      .split(/\r?\n/)[0]
+      .trim();
+    if (rel) {
+      const nested = path.join(root, rel, 'skywalk-sdd');
+      if (
+        fs.existsSync(path.join(nested, 'log.cjs'))
+        || fs.existsSync(path.join(nested, 'log.js'))
+      ) {
+        return nested;
+      }
+    }
+  }
+  return null;
+}
+
+function hasTelemetryCli(dir) {
+  return Boolean(resolveSkywalkDir(dir));
+}
+
+function findProjectRoot(startDir) {
+  if (!startDir) return '';
+  let current = path.resolve(startDir);
+  for (let i = 0; i < 25; i++) {
+    if (hasTelemetryCli(current) || fs.existsSync(path.join(current, '.sdd-spec-root'))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return '';
+    current = parent;
+  }
+  return '';
+}
+
+function getProjectRoot(input, provider = 'codebuddy') {
+  const toolInput = input.tool_input || input.toolInput || {};
+  const envKey = PROJECT_ENV_KEYS[provider] || PROJECT_ENV_KEYS.codebuddy;
+  const candidates = [
+    toolInput.cwd,
+    input.cwd,
+    input.project_root,
+    process.env[envKey],
+    process.env.PWD,
+    process.cwd(),
+  ].filter(Boolean);
+  for (const dir of candidates) {
+    const root = findProjectRoot(dir);
+    if (root) return root;
+  }
+  return process.cwd();
+}
+
+function safeChangeName(name) {
+  if (!name) return '';
+  return String(name)
+    .toLowerCase()
+    .replace(/[\s_]+/g, '-')
+    .replace(/[^a-z0-9一-鿿\-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function findActiveApplyStage(projectRoot) {
+  const skywalk = resolveSkywalkDir(projectRoot);
+  const stateDir = skywalk
+    ? path.join(skywalk, 'state')
+    : path.join(projectRoot, 'skywalk-sdd', 'state');
+  if (!fs.existsSync(stateDir)) return null;
+
+  let latest = null;
+  for (const file of fs.readdirSync(stateDir).filter((f) => f.endsWith('.json'))) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(stateDir, file), 'utf8'));
+      const event = data.event || null;
+      if (event && event.command === 'apply') {
+        if (!latest || new Date(event.timestamp) > new Date(latest.timestamp)) {
+          latest = event;
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+  return latest;
+}
+
+function hasCompletedCheck(projectRoot, changeName) {
+  const safeName = safeChangeName(changeName);
+  const skywalk = resolveSkywalkDir(projectRoot);
+  const eventsChangeDir = skywalk
+    ? path.join(skywalk, 'events', safeName)
+    : path.join(projectRoot, 'skywalk-sdd', 'events', safeName);
+  if (!fs.existsSync(eventsChangeDir)) return false;
+
+  const jsonlFiles = fs.readdirSync(eventsChangeDir)
+    .filter((f) => f.endsWith('.jsonl'))
+    .sort()
+    .reverse();
+
+  for (const file of jsonlFiles) {
+    try {
+      const lines = fs.readFileSync(path.join(eventsChangeDir, file), 'utf-8')
+        .split('\n')
+        .filter(Boolean);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const event = JSON.parse(lines[i]);
+          if (
+            event.type === 'stage_end' &&
+            event.command === 'check' &&
+            (event.result === 'success' || event.result === 'partial')
+          ) {
+            return true;
+          }
+        } catch {
+          // skip
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+  return false;
+}
+
+function getPassedChanges(projectRoot) {
+  if (!projectRoot) return [];
+  const changesDir = path.join(projectRoot, 'openspec', 'changes');
+  if (!fs.existsSync(changesDir)) return [];
+
+  const passed = [];
+  try {
+    for (const entry of fs.readdirSync(changesDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.') || entry.name === 'archive') continue;
+      if (hasCompletedCheck(projectRoot, entry.name)) {
+        passed.push(entry.name);
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return passed;
+}
+
+function isOpsxApplySkill(toolInput) {
+  if (!toolInput) return false;
+  let input;
+  if (typeof toolInput === 'string') {
+    try { input = JSON.parse(toolInput); } catch { return false; }
+  } else {
+    input = toolInput;
+  }
+  if (!input || typeof input !== 'object') return false;
+  return (input.skill || '') === 'opsx-apply';
+}
+
+function extractChangeName(toolInput) {
+  if (!toolInput) return null;
+  let input;
+  if (typeof toolInput === 'string') {
+    try { input = JSON.parse(toolInput); } catch { return null; }
+  } else {
+    input = toolInput;
+  }
+  if (!input || typeof input !== 'object') return null;
+
+  const args = input.args || '';
+  if (!args.trim()) return null;
+  const trimmed = args.trim();
+  const changeFlagMatch = trimmed.match(/^--change\s+(.+)$/);
+  if (changeFlagMatch) {
+    return safeChangeName(changeFlagMatch[1].trim().split(/\s+/)[0]);
+  }
+  return safeChangeName(trimmed.split(/\s+/)[0]);
+}
+
+function blockWithReason(reason, extra) {
+  console.log(JSON.stringify({ decision: 'block', reason, ...(extra || {}) }));
+  process.exit(2);
+}
+
+function allowExit(extra) {
+  if (extra) {
+    console.log(JSON.stringify({ decision: 'allow', ...extra }));
+  }
+  process.exit(0);
+}
+
+function evaluateApplyWriteGate(input, provider = 'codebuddy') {
+  const toolName = String(input.tool_name || input.toolName || '');
+  if (!toolName) {
+    return {
+      action: 'block',
+      reason: 'stdin 缺少必要字段 tool_name，无法执行 apply 写入门禁检查',
+    };
+  }
+  if (toolName !== 'Write' && toolName !== 'Edit') {
+    return { action: 'allow' };
+  }
+
+  const projectRoot = getProjectRoot(input, provider);
+  const activeApply = findActiveApplyStage(projectRoot);
+  if (!activeApply) {
+    return { action: 'allow' };
+  }
+  if (hasCompletedCheck(projectRoot, activeApply.change)) {
+    return { action: 'allow' };
+  }
+
+  const changeName = activeApply.change || 'unknown';
+  return {
+    action: 'block',
+    reason: `[SDD Apply Gate] 检测到 apply 阶段正在执行（change: ${changeName}），但 check 阶段尚未完成。\n\n请先执行 /opsx-check 完成质量门禁检查，再执行 /opsx-apply 进行代码实施。\n\n操作顺序：/opsx-check → /opsx-apply`,
+  };
+}
+
+function evaluateSkillApplyGate(input, provider = 'codebuddy') {
+  const toolName = String(input.tool_name || input.toolName || '');
+  if (!toolName) {
+    return {
+      action: 'block',
+      reason: 'stdin 缺少必要字段 tool_name，无法执行 Skill apply 门禁检查',
+    };
+  }
+  if (toolName !== 'Skill') {
+    return { action: 'allow' };
+  }
+
+  const toolInput = input.tool_input;
+  if (!isOpsxApplySkill(toolInput)) {
+    return { action: 'allow' };
+  }
+
+  const projectRoot = getProjectRoot(input, provider);
+  if (!findProjectRoot(projectRoot)) {
+    return { action: 'allow' };
+  }
+
+  const changeName = extractChangeName(toolInput);
+  if (changeName) {
+    if (hasCompletedCheck(projectRoot, changeName)) {
+      return { action: 'allow' };
+    }
+    return {
+      action: 'block',
+      reason: `变更 "${changeName}" 尚未完成 check 阶段。请先执行 /opsx-check ${changeName} 完成检查后再 apply。`,
+    };
+  }
+
+  const passedChanges = getPassedChanges(projectRoot);
+  if (passedChanges.length === 0) {
+    return {
+      action: 'block',
+      reason: '当前项目没有任何变更已完成 check 阶段。请先执行 /opsx-check <change-name> 完成检查后再 apply。',
+    };
+  }
+
+  const msg = passedChanges.length === 1
+    ? `检测到已通过 check 的变更: "${passedChanges[0]}"，允许进入 apply。`
+    : `检测到 ${passedChanges.length} 个已通过 check 的变更: ${passedChanges.join(', ')}，允许进入 apply。`;
+  return { action: 'allow', reason: msg };
+}
+
+function evaluatePreToolDangerGate(input) {
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || input.command || '');
+  const dangerousPatterns = [
+    /\brm\s+-rf\b/i,
+    /\brmdir\s+\/s\b/i,
+    /\bdel\s+\/[fsq]/i,
+    /\bgit\s+reset\s+--hard\b/i,
+    /\bgit\s+clean\s+-fdx\b/i,
+    /\bRemove-Item\b.*\b-Recurse\b.*\b-Force\b/i,
+  ];
+  if (dangerousPatterns.some((pattern) => pattern.test(command))) {
+    return {
+      action: 'block',
+      reason: 'Blocked by SDD hook: destructive command requires explicit user approval.',
+    };
+  }
+  return { action: 'allow' };
+}
+
+module.exports = {
+  PROJECT_ENV_KEYS,
+  readStdin,
+  parseHookInput,
+  normalizeHookInput,
+  resolveSkywalkDir,
+  hasTelemetryCli,
+  findProjectRoot,
+  getProjectRoot,
+  safeChangeName,
+  findActiveApplyStage,
+  hasCompletedCheck,
+  getPassedChanges,
+  isOpsxApplySkill,
+  extractChangeName,
+  blockWithReason,
+  allowExit,
+  evaluateApplyWriteGate,
+  evaluateSkillApplyGate,
+  evaluatePreToolDangerGate,
+};

package/templates/hooks/codebuddy/hooks/sdd-apply-test-gate.cjs

@@ -341,6 +341,38 @@ function hasExistingWarning(events, code) {
   );
 }
 
+/** B3: 检测 TDD 时间异常（每任务平均耗时 <120 秒） */
+function detectTimingAnomaly(events, sinceTimestamp) {
+  const since = sinceTimestamp ? new Date(sinceTimestamp).getTime() : 0;
+  const filtered = (events || []).filter(
+    (e) => new Date(e.timestamp || 0).getTime() >= since
+  );
+  const taskUpdates = filtered.filter(
+    (e) => e.type === 'task_update' && e.status === 'completed'
+  );
+  if (taskUpdates.length < 10) return null;
+  const timestamps = filtered
+    .map((e) => new Date(e.timestamp || 0).getTime())
+    .filter((t) => t > 0);
+  if (timestamps.length === 0) return null;
+  const firstTs = Math.min(...timestamps);
+  const lastTs = Math.max(...timestamps);
+  const totalDurationSec = (lastTs - firstTs) / 1000;
+  const perTaskSec = totalDurationSec / taskUpdates.length;
+  const TDD_MIN_PER_TASK = 120;
+  if (perTaskSec < TDD_MIN_PER_TASK) {
+    return {
+      anomaly: true,
+      perTask: Math.round(perTaskSec),
+      totalTasks: taskUpdates.length,
+      totalDuration: Math.round(totalDurationSec),
+      testEvidence: filtered.filter((e) => e.type === 'test_result').length,
+      threshold: TDD_MIN_PER_TASK,
+    };
+  }
+  return null;
+}
+
 // ── 主逻辑（仅直接执行时运行；被 require 时跳过，便于单元测试） ──
 if (require.main === module) {
   const parsed = parseHookInput(readStdin(), { strict: true });
@@ -390,6 +422,14 @@ if (require.main === module) {
           'tdd 策略下 apply 阶段未检测到失败的测试结果（红灯），测试骨架可能未经 RED 验证即标记完成');
       }
     }
+    // B3: TDD 时间异常检测
+    const timingAnomaly = detectTimingAnomaly(warningEvents, activeApply.timestamp);
+    if (timingAnomaly && !hasExistingWarning(warningEvents, 'tdd_timing_anomaly')) {
+      recordWarning(projectRoot, warningCtx, 'tdd_timing_anomaly',
+        'TDD 时间异常：' + timingAnomaly.totalTasks + ' 个任务在 ' + timingAnomaly.totalDuration +
+        ' 秒内完成（每任务 ' + timingAnomaly.perTask + ' 秒，阈值 ' + timingAnomaly.threshold +
+        ' 秒），测试证据 ' + timingAnomaly.testEvidence + ' 条。可能存在批量执行或跳过 TDD 红绿循环的情况。');
+    }
   } catch {
     // 警告检测失败不阻断主流程
   }
@@ -418,6 +458,7 @@ module.exports = {
   detectReusedTestResults,
   detectProcessNoteGap,
   detectMissingTddRed,
+  detectTimingAnomaly,
   hasExistingWarning,
   isRealTestDetails,
   isStrictTestEvidence,