kld-sdd 2.6.16 → 2.6.21

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

@@ -346,6 +346,325 @@ function evaluatePreToolDangerGate(input) {
   return { action: 'allow' };
 }
 
+// ═══════════════════════════════════════════════════════════════
+// TDD 批量执行检测工具函数（E1/E2/E3 对应实现）
+// ═══════════════════════════════════════════════════════════════
+
+/**
+ * 从事件列表中提取 TDD 测试事件。
+ * 关键：对同一 task_id 只取最新的 test_result 事件（"最新事件优先"机制），
+ * 这样 agent 重做产生的新事件会覆盖旧的批量事件。
+ */
+function extractTddTestEvents(events, sinceTimestamp) {
+  const since = sinceTimestamp ? new Date(sinceTimestamp).getTime() : 0;
+  const all = (events || [])
+    .filter((e) => e && e.type === 'test_result' && e.details && e.details.test_results)
+    .filter((e) => {
+      const ts = new Date(e.timestamp || 0).getTime();
+      return ts >= since;
+    })
+    .map((e) => ({
+      task_id: e.task_id || '',
+      phase: (e.details.test_results.tdd_phase || 'unknown').toLowerCase(),
+      result: e.result || '',
+      timestamp_ms: new Date(e.timestamp || 0).getTime(),
+      timestamp: e.timestamp,
+    }))
+    .filter((e) => ['red', 'green', 'refactor'].includes(e.phase));
+
+  // "最新事件优先"：对同一 task_id 只保留 timestamp 最大的事件
+  const latestPerTask = new Map();
+  for (const ev of all) {
+    const existing = latestPerTask.get(ev.task_id);
+    if (!existing || ev.timestamp_ms > existing.timestamp_ms) {
+      latestPerTask.set(ev.task_id, ev);
+    }
+  }
+
+  return Array.from(latestPerTask.values()).sort((a, b) => a.timestamp_ms - b.timestamp_ms);
+}
+
+/**
+ * 从 tasks.md 内容构建 RED→GREEN 配对映射。
+ * 优先从 dependsOn 字段解析，退化为编号推断。
+ */
+function buildPairMap(tasksMdContent) {
+  const pairMap = {};
+  if (!tasksMdContent) return pairMap;
+
+  // 尝试从 dependsOn 字段解析
+  const taskBlocks = tasksMdContent.split(/^###\s+/m);
+  for (const block of taskBlocks) {
+    // 匹配 TASK-AUTH-RED-1 或 TASK-BOOK-GREEN-7 格式
+    const idMatch = block.match(/^\[?(TASK-[A-Z]+-(?:RED|GREEN|REFACTOR)-\d+)\]?/i);
+    if (!idMatch) continue;
+    const taskId = idMatch[1].toUpperCase();
+    // 匹配 dependsOn: TASK-AUTH-RED-1（处理 markdown ** 粗体标记）
+    const depMatch = block.match(/dependsOn[\s\*]*[:：]\s*(TASK-[A-Z]+-RED-\d+)/i);
+    if (depMatch) {
+      pairMap[taskId] = depMatch[1].toUpperCase();
+    }
+  }
+
+  // 退化为编号推断：GREEN-N 配 RED-N
+  const redNums = new Set();
+  const greenNums = new Set();
+  const allTaskIds = tasksMdContent.match(/TASK-[A-Z]+-(?:RED|GREEN)-\d+/gi) || [];
+  for (const id of allTaskIds) {
+    const upper = id.toUpperCase();
+    if (upper.includes('-RED-')) {
+      const num = upper.match(/RED-(\d+)/);
+      if (num) redNums.add(parseInt(num[1]));
+    } else if (upper.includes('-GREEN-')) {
+      const num = upper.match(/GREEN-(\d+)/);
+      if (num) greenNums.add(parseInt(num[1]));
+    }
+  }
+  // 为没有 dependsOn 映射的 GREEN 补充编号推断
+  for (const num of greenNums) {
+    const greenId = `GREEN-${num}`;
+    const redId = `RED-${num}`;
+    const hasMapping = Object.keys(pairMap).some((k) => k.includes(greenId));
+    if (!hasMapping && redNums.has(num)) {
+      const greenPattern = new RegExp(`(TASK-[A-Z]+-\\d+-${greenId}-\\d+)`, 'i');
+      const redPattern = new RegExp(`(TASK-[A-Z]+-\\d+-${redId}-\\d+)`, 'i');
+      const greenMatch = tasksMdContent.match(greenPattern);
+      const redMatch = tasksMdContent.match(redPattern);
+      if (greenMatch && redMatch) {
+        pairMap[greenMatch[1].toUpperCase()] = redMatch[1].toUpperCase();
+      }
+    }
+  }
+
+  return pairMap;
+}
+
+/**
+ * 检测连续 RED 事件（无中间 GREEN）。
+ * 针对模式：RED-1→RED-2→RED-3→GREEN-1→GREEN-2→GREEN-3
+ * 注意：对"正确交错但极速"模式无效，保留防御其他批量模式。
+ */
+function detectConsecutiveReds(tddEvents) {
+  const violations = [];
+  let consecutiveReds = [];
+
+  for (const ev of tddEvents) {
+    if (ev.phase === 'red') {
+      consecutiveReds.push(ev);
+    } else {
+      if (consecutiveReds.length >= 2) {
+        violations.push({
+          type: 'consecutive_reds',
+          severity: 'critical',
+          red_events: consecutiveReds.map((r) => ({
+            task_id: r.task_id,
+            timestamp: r.timestamp,
+          })),
+          message: `检测到 ${consecutiveReds.length} 个连续 RED 事件无中间 GREEN：` +
+            consecutiveReds.map((r) => r.task_id).join(', ') +
+            '。TDD 要求每个 RED 后立即实现 GREEN。',
+        });
+      }
+      consecutiveReds = [];
+    }
+  }
+  if (consecutiveReds.length >= 2) {
+    violations.push({
+      type: 'consecutive_reds',
+      severity: 'critical',
+      red_events: consecutiveReds.map((r) => ({
+        task_id: r.task_id,
+        timestamp: r.timestamp,
+      })),
+      message: `检测到 ${consecutiveReds.length} 个连续 RED 事件无中间 GREEN：` +
+        consecutiveReds.map((r) => r.task_id).join(', ') +
+        '。TDD 要求每个 RED 后立即实现 GREEN。',
+    });
+  }
+  return violations;
+}
+
+/**
+ * 检测交错违规：RED-M 出现在 RED-N 和 GREEN-N 之间。
+ * 针对模式：RED-1→RED-2→GREEN-1→GREEN-2
+ * 注意：对"正确交错但极速"模式无效，保留防御其他批量模式。
+ */
+function detectInterleavingViolation(tddEvents, pairMap) {
+  const violations = [];
+  if (!pairMap || Object.keys(pairMap).length === 0) return violations;
+
+  for (const greenEv of tddEvents.filter((e) => e.phase === 'green')) {
+    const pairedRedId = pairMap[greenEv.task_id];
+    if (!pairedRedId) continue;
+
+    const redEv = tddEvents.find((e) => e.task_id === pairedRedId && e.phase === 'red');
+    if (!redEv) continue;
+
+    // 检查 RED-N 和 GREEN-N 之间是否有其他 RED 事件
+    const betweenReds = tddEvents.filter((e) =>
+      e.phase === 'red' &&
+      e.task_id !== pairedRedId &&
+      redEv.timestamp_ms < e.timestamp_ms &&
+      e.timestamp_ms < greenEv.timestamp_ms
+    );
+
+    if (betweenReds.length > 0) {
+      violations.push({
+        type: 'interleaving_violation',
+        severity: 'critical',
+        green_task: greenEv.task_id,
+        red_task: pairedRedId,
+        between_reds: betweenReds.map((r) => ({ task_id: r.task_id, timestamp: r.timestamp })),
+        message: `交错违规：${pairedRedId} 和 ${greenEv.task_id} 之间存在其他 RED 事件：` +
+          betweenReds.map((r) => r.task_id).join(', '),
+      });
+    }
+  }
+  return violations;
+}
+
+/**
+ * E3: 时间戳聚类检测（升级版）。
+ * 4+ 事件在 10 秒内 → critical (block)
+ * 3 事件在 10 秒内 → warning
+ */
+function detectTimestampClustering(tddEvents) {
+  const CLUSTER_WINDOW_MS = 10_000;
+  const CLUSTER_BLOCK_THRESHOLD = 4;
+  const CLUSTER_WARN_THRESHOLD = 3;
+
+  for (let i = 0; i <= tddEvents.length - CLUSTER_WARN_THRESHOLD; i++) {
+    const windowStart = tddEvents[i].timestamp_ms;
+    let count = 0;
+    for (let j = i; j < tddEvents.length; j++) {
+      if (tddEvents[j].timestamp_ms - windowStart < CLUSTER_WINDOW_MS) {
+        count++;
+      } else {
+        break;
+      }
+    }
+    if (count >= CLUSTER_BLOCK_THRESHOLD) {
+      return [{
+        type: 'timestamp_clustering',
+        severity: 'critical',
+        event_count: count,
+        window_seconds: (tddEvents[i + count - 1].timestamp_ms - windowStart) / 1000,
+        events: tddEvents.slice(i, i + count).map((e) => ({
+          task_id: e.task_id,
+          phase: e.phase,
+          timestamp: e.timestamp,
+        })),
+        message: `时间戳聚类：${count} 个事件在 ${(tddEvents[i + count - 1].timestamp_ms - windowStart) / 1000} 秒内集中发生`,
+      }];
+    }
+    if (count >= CLUSTER_WARN_THRESHOLD) {
+      return [{
+        type: 'timestamp_clustering',
+        severity: 'warning',
+        event_count: count,
+        window_seconds: (tddEvents[i + count - 1].timestamp_ms - windowStart) / 1000,
+        events: tddEvents.slice(i, i + count).map((e) => ({
+          task_id: e.task_id,
+          phase: e.phase,
+          timestamp: e.timestamp,
+        })),
+        message: `时间戳聚类：${count} 个事件在 ${(tddEvents[i + count - 1].timestamp_ms - windowStart) / 1000} 秒内集中发生`,
+      }];
+    }
+  }
+  return [];
+}
+
+/**
+ * E2: 极速配对检测。
+ * 针对实际违规模式："正确交错但极速完成"
+ * 3+ 对 RED→GREEN 间隔 < 5 秒 → critical (block)
+ * 2 对 → warning
+ */
+function detectRapidPairing(tddEvents, pairMap) {
+  const RAPID_PAIR_THRESHOLD_MS = 5_000;
+  const RAPID_PAIR_MIN_COUNT = 3;
+
+  if (!pairMap || Object.keys(pairMap).length === 0) return [];
+
+  const pairs = [];
+  for (const greenEv of tddEvents.filter((e) => e.phase === 'green')) {
+    const pairedRedId = pairMap[greenEv.task_id];
+    if (!pairedRedId) continue;
+    const redEv = tddEvents.find((e) => e.task_id === pairedRedId && e.phase === 'red');
+    if (!redEv) continue;
+    const gap = greenEv.timestamp_ms - redEv.timestamp_ms;
+    if (gap >= 0) {
+      pairs.push({
+        red_task_id: pairedRedId,
+        green_task_id: greenEv.task_id,
+        gap_ms: gap,
+        gap_seconds: gap / 1000,
+        red_timestamp: redEv.timestamp,
+        green_timestamp: greenEv.timestamp,
+      });
+    }
+  }
+
+  const rapidPairs = pairs.filter((p) => p.gap_ms < RAPID_PAIR_THRESHOLD_MS);
+
+  if (rapidPairs.length >= RAPID_PAIR_MIN_COUNT) {
+    return [{
+      type: 'rapid_pairing',
+      severity: 'critical',
+      rapid_pair_count: rapidPairs.length,
+      rapid_pairs: rapidPairs.map((p) => ({
+        red: p.red_task_id,
+        green: p.green_task_id,
+        gap_seconds: p.gap_seconds,
+      })),
+      message: `检测到 ${rapidPairs.length} 个极速 RED→GREEN 配对（间隔 < 5 秒）：` +
+        rapidPairs.map((p) => `${p.red_task_id}→${p.green_task_id}(${p.gap_seconds.toFixed(1)}秒)`).join(', '),
+    }];
+  }
+  if (rapidPairs.length >= 2) {
+    return [{
+      type: 'rapid_pairing',
+      severity: 'warning',
+      rapid_pair_count: rapidPairs.length,
+      rapid_pairs: rapidPairs.map((p) => ({
+        red: p.red_task_id,
+        green: p.green_task_id,
+        gap_seconds: p.gap_seconds,
+      })),
+      message: `检测到 ${rapidPairs.length} 个极速 RED→GREEN 配对（间隔 < 5 秒）`,
+    }];
+  }
+  return [];
+}
+
+/**
+ * 整合所有 TDD 批量执行检测。
+ * 调用此函数即可获得完整的违规分析。
+ */
+function detectTddBatchPattern(events, sinceTimestamp, tasksMdContent) {
+  const tddEvents = extractTddTestEvents(events, sinceTimestamp);
+  const pairMap = buildPairMap(tasksMdContent || '');
+
+  const allViolations = [
+    ...detectConsecutiveReds(tddEvents),
+    ...detectInterleavingViolation(tddEvents, pairMap),
+    ...detectTimestampClustering(tddEvents),
+    ...detectRapidPairing(tddEvents, pairMap),
+  ];
+
+  const hasCritical = allViolations.some((v) => v.severity === 'critical');
+  const hasWarning = allViolations.some((v) => v.severity === 'warning');
+
+  return {
+    has_violation: allViolations.length > 0,
+    severity: hasCritical ? 'critical' : (hasWarning ? 'warning' : 'none'),
+    violations: allViolations,
+    tdd_events: tddEvents,
+    pair_map: pairMap,
+  };
+}
+
 module.exports = {
   PROJECT_ENV_KEYS,
   readStdin,
@@ -366,4 +685,12 @@ module.exports = {
   evaluateApplyWriteGate,
   evaluateSkillApplyGate,
   evaluatePreToolDangerGate,
+  // TDD 批量执行检测
+  extractTddTestEvents,
+  buildPairMap,
+  detectConsecutiveReds,
+  detectInterleavingViolation,
+  detectTimestampClustering,
+  detectRapidPairing,
+  detectTddBatchPattern,
 };

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

@@ -341,7 +341,9 @@ function hasExistingWarning(events, code) {
   );
 }
 
-/** B3: 检测 TDD 时间异常（每任务平均耗时 <120 秒） */
+/** B3: 检测 TDD 时间异常
+ *  B1/B2 改进：降低阈值，分两级（30s 阻断 / 60s 警告），最少 3 任务触发
+ *  返回 { anomaly, severity, perTask, totalTasks, totalDuration, testEvidence, threshold } */
 function detectTimingAnomaly(events, sinceTimestamp) {
   const since = sinceTimestamp ? new Date(sinceTimestamp).getTime() : 0;
   const filtered = (events || []).filter(
@@ -350,7 +352,7 @@ function detectTimingAnomaly(events, sinceTimestamp) {
   const taskUpdates = filtered.filter(
     (e) => e.type === 'task_update' && e.status === 'completed'
   );
-  if (taskUpdates.length < 10) return null;
+  if (taskUpdates.length < 3) return null;  // B2: 10 → 3
   const timestamps = filtered
     .map((e) => new Date(e.timestamp || 0).getTime())
     .filter((t) => t > 0);
@@ -359,15 +361,28 @@ function detectTimingAnomaly(events, sinceTimestamp) {
   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) {
+  const BLOCK_THRESHOLD = 30;   // B1: < 30s/任务 → block
+  const WARN_THRESHOLD = 60;    // B1: < 60s/任务 → warn
+  if (perTaskSec < BLOCK_THRESHOLD) {
     return {
       anomaly: true,
+      severity: 'critical',
       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,
+      threshold: BLOCK_THRESHOLD,
+    };
+  }
+  if (perTaskSec < WARN_THRESHOLD) {
+    return {
+      anomaly: true,
+      severity: 'warning',
+      perTask: Math.round(perTaskSec),
+      totalTasks: taskUpdates.length,
+      totalDuration: Math.round(totalDurationSec),
+      testEvidence: filtered.filter((e) => e.type === 'test_result').length,
+      threshold: WARN_THRESHOLD,
     };
   }
   return null;
@@ -422,13 +437,43 @@ if (require.main === module) {
           'tdd 策略下 apply 阶段未检测到失败的测试结果（红灯），测试骨架可能未经 RED 验证即标记完成');
       }
     }
-    // B3: TDD 时间异常检测
+    // B3: TDD 时间异常检测（B1 改进：critical 级阻断）
     const timingAnomaly = detectTimingAnomaly(warningEvents, activeApply.timestamp);
     if (timingAnomaly && !hasExistingWarning(warningEvents, 'tdd_timing_anomaly')) {
-      recordWarning(projectRoot, warningCtx, 'tdd_timing_anomaly',
-        'TDD 时间异常：' + timingAnomaly.totalTasks + ' 个任务在 ' + timingAnomaly.totalDuration +
+      const msg = 'TDD 时间异常：' + timingAnomaly.totalTasks + ' 个任务在 ' + timingAnomaly.totalDuration +
         ' 秒内完成（每任务 ' + timingAnomaly.perTask + ' 秒，阈值 ' + timingAnomaly.threshold +
-        ' 秒），测试证据 ' + timingAnomaly.testEvidence + ' 条。可能存在批量执行或跳过 TDD 红绿循环的情况。');
+        ' 秒），测试证据 ' + timingAnomaly.testEvidence + ' 条。可能存在批量执行或跳过 TDD 红绿循环的情况。';
+      if (timingAnomaly.severity === 'critical') {
+        // B1: critical 级直接阻断
+        recordWarning(projectRoot, warningCtx, 'tdd_timing_anomaly', msg);
+        block('block',
+          `⛔ [SDD Apply Test Gate] TDD 时间异常阻断\n\n${msg}\n\n` +
+          '每任务平均耗时 < 30 秒，不可能完成真实的 RED→GREEN 循环。\n' +
+          '请回退并逐对重新执行 TDD 循环。',
+          { test_strategy: warningCtx.test_strategy, change: activeApply.change }
+        );
+      } else if (!hasExistingWarning(warningEvents, 'tdd_timing_anomaly')) {
+        recordWarning(projectRoot, warningCtx, 'tdd_timing_anomaly', msg);
+      }
+    }
+    // B3: TDD 批量执行模式检测（E2 极速配对 + E3 时间戳聚类 + 连续 RED + 交错违规）
+    const batchPattern = core.detectTddBatchPattern(
+      warningEvents,
+      activeApply.timestamp,
+      null  // 无 tasks.md 内容，退化为编号推断
+    );
+    if (batchPattern.has_violation && batchPattern.severity === 'critical') {
+      const criticalMsgs = batchPattern.violations
+        .filter(v => v.severity === 'critical')
+        .map(v => `【${v.type}】${v.message}`)
+        .join('\n');
+      recordWarning(projectRoot, warningCtx, 'tdd_batch_execution',
+        `TDD 批量执行检测：${criticalMsgs}`);
+      block('block',
+        `⛔ [SDD Apply Test Gate] TDD 批量执行违规\n\n${criticalMsgs}\n\n` +
+        '请回退并逐对重新执行 TDD 循环。',
+        { test_strategy: warningCtx.test_strategy, change: activeApply.change }
+      );
     }
   } catch {
     // 警告检测失败不阻断主流程

package/templates/hooks/codebuddy/hooks/sdd-mid-checkpoint.cjs

@@ -4,18 +4,20 @@
 /**
  * SDD Mid-Apply Checkpoint Hook
  *
- * 每完成 10 个 TDD 任务后强制检查点，验证 telemetry 证据链完整性。
- * 不阻断，仅输出警告提醒。
+ * 每完成 5 个 TDD 任务后强制检查点，验证 telemetry 证据链完整性。
+ * C1 改进：证据比率 < 50% 或检测到 critical 批量违规时阻断。
+ * C2 改进：检查点间隔从 10 降为 5。
+ * C3 改进：新增连续 RED + 极速配对检测。
  *
  * 触发点：PostToolUse(Bash) - 当检测到测试命令执行后
- * 退出码：0（不阻断）
+ * 退出码：0 放行 | 2 阻断（C1 改进：严重违规时阻断）
  */
 
 const fs = require('fs');
 const path = require('path');
 const core = require('./hook-gate-core.cjs');
 
-const CHECKPOINT_INTERVAL = 10;
+const CHECKPOINT_INTERVAL = 5;  // C2: 10 → 5
 
 function loadChangeEvents(projectRoot, changeName) {
   const skywalk = core.resolveSkywalkDir(projectRoot);
@@ -87,21 +89,76 @@ if (require.main === module) {
 
   const expectedMin = Math.floor(completedCount * 0.8);
   const actualEvidence = redCount + greenCount;
+  const evidenceRatio = completedCount > 0 ? actualEvidence / completedCount : 1;
+
+  // C3: TDD 批量执行模式检测
+  const batchPattern = core.detectTddBatchPattern(
+    events,
+    activeStage.timestamp,
+    null  // 无 tasks.md 内容，退化为编号推断
+  );
+
+  // C1: critical 批量违规 → 阻断
+  if (batchPattern.has_violation && batchPattern.severity === 'critical') {
+    const criticalMsgs = batchPattern.violations
+      .filter(v => v.severity === 'critical')
+      .map(v => `【${v.type}】${v.message}`)
+      .join('\n');
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: '⛔ [SDD Mid-Checkpoint] TDD 批量执行违规（' + completedCount + ' 任务已完成）\n\n' +
+        criticalMsgs + '\n\n' +
+        '请回退并逐对重新执行 TDD 循环。',
+    }));
+    process.exit(2);
+  }
+
+  // C1: 证据比率 < 50% → 阻断
+  if (evidenceRatio < 0.5) {
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: '⛔ [SDD Mid-Checkpoint] 测试证据严重不足（' + completedCount + ' 任务已完成）\n' +
+        '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+        '  task_update 事件: ' + completedCount + '\n' +
+        '  test_result 事件: ' + actualEvidence + ' (RED: ' + redCount + ', GREEN: ' + greenCount + ')\n' +
+        '  证据比率: ' + Math.round(evidenceRatio * 100) + '%（阈值 50%）\n\n' +
+        '  请确认你仍在遵循严格 RED→GREEN 循环。\n' +
+        '  如果最近的任务跳过了 TDD，请回退并补做。\n' +
+        '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━',
+    }));
+    process.exit(2);
+  }
 
-  if (actualEvidence < expectedMin) {
+  // 证据比率 < 80% → 警告（不阻断）
+  if (evidenceRatio < 0.8) {
     console.log(JSON.stringify({
       decision: 'allow',
       message: '\n⚠️ TDD 中途检查点 [' + completedCount + ' 任务已完成]\n' +
         '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
         '  task_update 事件: ' + completedCount + '\n' +
         '  test_result 事件: ' + actualEvidence + ' (RED: ' + redCount + ', GREEN: ' + greenCount + ')\n' +
-        '  期望最少: ' + expectedMin + '\n\n' +
+        '  证据比率: ' + Math.round(evidenceRatio * 100) + '%\n\n' +
         '  ⚠️ 测试证据不足！请确认你仍在遵循严格 RED→GREEN 循环。\n' +
         '  如果最近的任务跳过了 TDD，请回退并补做。\n' +
         '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n',
     }));
   }
 
+  // C3: warning 级批量违规 → 警告（不阻断）
+  if (batchPattern.has_violation && batchPattern.severity === 'warning') {
+    const warningMsgs = batchPattern.violations
+      .filter(v => v.severity === 'warning')
+      .map(v => `【${v.type}】${v.message}`)
+      .join('\n');
+    console.log(JSON.stringify({
+      decision: 'allow',
+      message: '\n⚠️ TDD 中途检查点 — 批量执行警告\n' +
+        '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n' +
+        warningMsgs + '\n' +
+        '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n',
+    }));
+  }
+
   process.exit(0);
 }