kld-sdd 2.6.15 → 2.6.17

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

@@ -0,0 +1,696 @@
+/**
+ * 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' };
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 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,
+  parseHookInput,
+  normalizeHookInput,
+  resolveSkywalkDir,
+  hasTelemetryCli,
+  findProjectRoot,
+  getProjectRoot,
+  safeChangeName,
+  findActiveApplyStage,
+  hasCompletedCheck,
+  getPassedChanges,
+  isOpsxApplySkill,
+  extractChangeName,
+  blockWithReason,
+  allowExit,
+  evaluateApplyWriteGate,
+  evaluateSkillApplyGate,
+  evaluatePreToolDangerGate,
+  // TDD 批量执行检测
+  extractTddTestEvents,
+  buildPairMap,
+  detectConsecutiveReds,
+  detectInterleavingViolation,
+  detectTimestampClustering,
+  detectRapidPairing,
+  detectTddBatchPattern,
+};