kld-sdd 2.6.15 → 2.6.17

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

@@ -341,6 +341,53 @@ function hasExistingWarning(events, code) {
   );
 }
 
+/** 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(
+    (e) => new Date(e.timestamp || 0).getTime() >= since
+  );
+  const taskUpdates = filtered.filter(
+    (e) => e.type === 'task_update' && e.status === 'completed'
+  );
+  if (taskUpdates.length < 3) return null;  // B2: 10 → 3
+  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 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: 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;
+}
+
 // ── 主逻辑（仅直接执行时运行；被 require 时跳过，便于单元测试） ──
 if (require.main === module) {
   const parsed = parseHookInput(readStdin(), { strict: true });
@@ -390,6 +437,44 @@ if (require.main === module) {
           'tdd 策略下 apply 阶段未检测到失败的测试结果（红灯），测试骨架可能未经 RED 验证即标记完成');
       }
     }
+    // B3: TDD 时间异常检测（B1 改进：critical 级阻断）
+    const timingAnomaly = detectTimingAnomaly(warningEvents, activeApply.timestamp);
+    if (timingAnomaly && !hasExistingWarning(warningEvents, 'tdd_timing_anomaly')) {
+      const msg = 'TDD 时间异常：' + timingAnomaly.totalTasks + ' 个任务在 ' + timingAnomaly.totalDuration +
+        ' 秒内完成（每任务 ' + timingAnomaly.perTask + ' 秒，阈值 ' + timingAnomaly.threshold +
+        ' 秒），测试证据 ' + 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 {
     // 警告检测失败不阻断主流程
   }
@@ -418,6 +503,7 @@ module.exports = {
   detectReusedTestResults,
   detectProcessNoteGap,
   detectMissingTddRed,
+  detectTimingAnomaly,
   hasExistingWarning,
   isRealTestDetails,
   isStrictTestEvidence,

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

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * SDD Mid-Apply Checkpoint Hook
+ *
+ * 每完成 5 个 TDD 任务后强制检查点，验证 telemetry 证据链完整性。
+ * C1 改进：证据比率 < 50% 或检测到 critical 批量违规时阻断。
+ * C2 改进：检查点间隔从 10 降为 5。
+ * C3 改进：新增连续 RED + 极速配对检测。
+ *
+ * 触发点：PostToolUse(Bash) - 当检测到测试命令执行后
+ * 退出码：0 放行 | 2 阻断（C1 改进：严重违规时阻断）
+ */
+
+const fs = require('fs');
+const path = require('path');
+const core = require('./hook-gate-core.cjs');
+
+const CHECKPOINT_INTERVAL = 5;  // C2: 10 → 5
+
+function loadChangeEvents(projectRoot, changeName) {
+  const skywalk = core.resolveSkywalkDir(projectRoot);
+  const safe = core.safeChangeName(changeName);
+  const dir = skywalk
+    ? path.join(skywalk, 'events', safe)
+    : path.join(projectRoot, 'skywalk-sdd', 'events', safe);
+  if (!fs.existsSync(dir)) return [];
+  const events = [];
+  for (const file of fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'))) {
+    try {
+      const lines = fs.readFileSync(path.join(dir, file), 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) { try { events.push(JSON.parse(line)); } catch {} }
+    } catch {}
+  }
+  return events;
+}
+
+function latestActiveStage(projectRoot) {
+  const skywalk = core.resolveSkywalkDir(projectRoot);
+  const stateDir = skywalk
+    ? path.join(skywalk, 'state')
+    : path.join(projectRoot, 'skywalk-sdd', 'state');
+  if (!fs.existsSync(stateDir)) return null;
+  return fs.readdirSync(stateDir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => { try { return JSON.parse(fs.readFileSync(path.join(stateDir, f), 'utf8')).event; } catch { return null; } })
+    .filter(Boolean)
+    .filter(e => e.command === 'apply')
+    .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())[0] || null;
+}
+
+if (require.main === module) {
+  const parsed = core.parseHookInput(core.readStdin(), { strict: false });
+  const input = core.normalizeHookInput(parsed.input || {});
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || '');
+
+  if (!/\b(npm|pnpm|yarn)\s+(test|run\s+test)\b|\bpytest\b|\bmvn\b.*\btest\b|\bgo\s+test\b|\bcargo\s+test\b/i.test(command)) {
+    process.exit(0);
+  }
+
+  const projectRoot = core.getProjectRoot(input, 'codebuddy');
+  const activeStage = latestActiveStage(projectRoot);
+  if (!activeStage) process.exit(0);
+
+  const events = loadChangeEvents(projectRoot, activeStage.change);
+  const since = new Date(activeStage.timestamp).getTime();
+
+  const taskUpdates = events.filter(e =>
+    e.type === 'task_update' && e.status === 'completed' &&
+    new Date(e.timestamp || 0).getTime() >= since);
+  const completedCount = taskUpdates.length;
+
+  if (completedCount === 0 || completedCount % CHECKPOINT_INTERVAL !== 0) {
+    process.exit(0);
+  }
+
+  const testResults = events.filter(e =>
+    e.type === 'test_result' &&
+    new Date(e.timestamp || 0).getTime() >= since);
+
+  const redCount = testResults.filter(e =>
+    e.result === 'failure' && e.details && e.details.test_results &&
+    e.details.test_results.tdd_phase === 'red').length;
+  const greenCount = testResults.filter(e =>
+    e.result === 'success' && e.details && e.details.test_results &&
+    e.details.test_results.tdd_phase === 'green').length;
+
+  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);
+  }
+
+  // 证据比率 < 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' +
+        '  证据比率: ' + 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);
+}
+
+module.exports = { loadChangeEvents, latestActiveStage, CHECKPOINT_INTERVAL };

package/templates/hooks/codebuddy/hooks/sdd-post-tool.cjs

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const { execFileSync } = require('child_process');
+const core = require('./hook-gate-core.cjs');
 
 function latestActiveStage(projectRoot) {
   const stateDir = path.join(projectRoot, 'skywalk-sdd', 'state');
@@ -76,6 +77,38 @@ function stableRunId(input, activeStage, command) {
     .slice(0, 20)}`;
 }
 
+function inferTddPhase(projectRoot, activeStage, testResult) {
+  const taskId = activeStage.task_id;
+  if (!taskId) return 'regression';
+
+  const skywalk = core.resolveSkywalkDir(projectRoot);
+  const safe = core.safeChangeName(activeStage.change);
+  const tasksCandidates = [
+    path.join(projectRoot, 'openspec', 'changes', activeStage.change, 'tasks.md'),
+    path.join(projectRoot, 'changes', activeStage.change, 'tasks.md'),
+  ];
+  let tasksPath = null;
+  for (const p of tasksCandidates) {
+    if (fs.existsSync(p)) { tasksPath = p; break; }
+  }
+  if (!tasksPath) return 'regression';
+
+  try {
+    const content = fs.readFileSync(tasksPath, 'utf8');
+    const escaped = taskId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp('### \\[' + escaped + '\\][\\s\\S]*?(?=### \\[TASK|$)');
+    const match = content.match(regex);
+    if (!match) return 'regression';
+    const block = match[0];
+    if (/测试-RED|test-red/i.test(block)) {
+      return testResult.result === 'failure' ? 'red' : 'red-passed-unexpectedly';
+    }
+    if (/实现-GREEN|impl-green/i.test(block)) return 'green';
+    if (/重构-REFACTOR|refactor/i.test(block)) return 'refactor';
+  } catch {}
+  return 'regression';
+}
+
 function inferRecord(command) {
   if (/\b(log\.cjs|log\.js)\s+record\b/.test(command)) return null;
   if (/\b(npm|pnpm|yarn)\s+(test|run\s+test)\b|\bpytest\b|\bmvn\b.*\btest\b|\bgo\s+test\b|\bcargo\s+test\b/i.test(command)) {
@@ -114,7 +147,8 @@ function recordTelemetry(projectRoot, activeStage, record, result, exitCodeKnown
       : (typeof toolResponse.exitCode === 'number'
         ? toolResponse.exitCode
         : (typeof toolResponse.success === 'boolean' ? (toolResponse.success ? 0 : 1) : null));
-    const tddPhase = toolInput.tdd_phase || input.tdd_phase || 'regression';
+    const tddPhase = toolInput.tdd_phase || input.tdd_phase ||
+      inferTddPhase(projectRoot, activeStage, inferred);
     details.test_results = {
       command: toolInput.command || record.details.command,
       tdd_phase: tddPhase,
@@ -194,6 +228,7 @@ if (require.main === module) {
 module.exports = {
   inferResult,
   inferRecord,
+  inferTddPhase,
   parseTestCounts,
   stableRunId,
   recordTelemetry,

package/templates/hooks/codebuddy/hooks/sdd-tdd-rhythm-gate.cjs

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * SDD TDD Rhythm Gate Hook
+ *
+ * 当 agent 修改 tasks.md 中的任务状态时，校验 TDD 证据链。
+ * 仅在 TDD 模式的 apply 阶段对 RED/GREEN/REFACTOR 任务生效。
+ *
+ * 触发点：PreToolUse(Write|Edit)
+ * 退出码：0 放行 | 2 阻断
+ */
+
+const fs = require('fs');
+const path = require('path');
+const core = require('./hook-gate-core.cjs');
+
+// ── 辅助函数 ──
+
+function loadChangeEvents(projectRoot, changeName) {
+  const skywalk = core.resolveSkywalkDir(projectRoot);
+  const safe = core.safeChangeName(changeName);
+  const dir = skywalk
+    ? path.join(skywalk, 'events', safe)
+    : path.join(projectRoot, 'skywalk-sdd', 'events', safe);
+  if (!fs.existsSync(dir)) return [];
+  const events = [];
+  for (const file of fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'))) {
+    try {
+      const lines = fs.readFileSync(path.join(dir, file), 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try { events.push(JSON.parse(line)); } catch {}
+      }
+    } catch {}
+  }
+  return events;
+}
+
+function readTestStrategy(projectRoot, changeName) {
+  const candidates = [
+    path.join(projectRoot, 'openspec', 'changes', changeName, 'proposal.md'),
+    path.join(projectRoot, 'changes', changeName, 'proposal.md'),
+  ];
+  for (const p of candidates) {
+    if (!fs.existsSync(p)) continue;
+    try {
+      const content = fs.readFileSync(p, 'utf8');
+      const match = content.match(/test-strategy:\s*(\S+)/);
+      if (match) {
+        const strategy = match[1].toLowerCase().trim();
+        if (strategy === 'none' || strategy === 'impl-first') return strategy;
+      }
+    } catch {}
+  }
+  return 'tdd';
+}
+
+function detectTaskType(lines, taskLineIndex) {
+  for (let i = taskLineIndex; i < Math.min(taskLineIndex + 30, lines.length); i++) {
+    const line = lines[i];
+    if (/测试-RED|test-red/i.test(line)) return 'red';
+    if (/实现-GREEN|impl-green/i.test(line)) return 'green';
+    if (/重构-REFACTOR|refactor/i.test(line)) return 'refactor';
+    if (/配置|数据层|接口层|接口测试|scaffold|migration/i.test(line)) return 'non-tdd';
+    if (/^### \[TASK/.test(line) && i > taskLineIndex) break;
+  }
+  return 'unknown';
+}
+
+function findPairedRedTaskId(content, greenTaskId) {
+  const escaped = greenTaskId.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(`### \\[${escaped}\\][\\s\\S]*?(?=### \\[TASK|$)`);
+  const match = content.match(regex);
+  if (!match) return null;
+  const depMatch = match[0].match(/- \*\*dependsOn\*\*:\s*(TASK-[A-Z]+-\d+)/);
+  return depMatch ? depMatch[1] : null;
+}
+
+function detectStatusChanges(oldContent, newContent) {
+  const changes = [];
+  const oldLines = oldContent.split('\n');
+  const newLines = newContent.split('\n');
+  let currentTaskId = null;
+  let currentTaskType = null;
+  for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
+    const oldLine = oldLines[i] || '';
+    const newLine = newLines[i] || '';
+    const taskMatch = newLine.match(/^### \[(TASK-[A-Z]+-\d+)\]/);
+    if (taskMatch) {
+      currentTaskId = taskMatch[1];
+      currentTaskType = detectTaskType(newLines, i);
+      continue;
+    }
+    if (oldLine.includes('**状态**: [ ] 未完成') &&
+        newLine.includes('**状态**: [x] 已完成')) {
+      changes.push({ taskId: currentTaskId, taskType: currentTaskType, line: i + 1 });
+    }
+  }
+  return changes;
+}
+
+// ── 主逻辑 ──
+
+if (require.main === module) {
+  const parsed = core.parseHookInput(core.readStdin(), { strict: false });
+  if (!parsed.ok) process.exit(0);
+  const input = core.normalizeHookInput(parsed.input || {});
+  const toolInput = input.tool_input || input.toolInput || {};
+  const filePath = toolInput.file_path || toolInput.filePath || '';
+
+  // 只检查 tasks.md
+  if (!filePath.endsWith('tasks.md')) process.exit(0);
+
+  const projectRoot = core.getProjectRoot(input, 'codebuddy');
+
+  // 仅在有活跃 apply 阶段时触发
+  const activeStage = core.findActiveApplyStage(projectRoot);
+  if (!activeStage) process.exit(0);
+
+  // 安全网 0: 非 TDD 模式直接放行
+  const testStrategy = readTestStrategy(projectRoot, activeStage.change);
+  if (testStrategy !== 'tdd') process.exit(0);
+
+  // 读取旧内容
+  let oldContent = '';
+  try { oldContent = fs.readFileSync(filePath, 'utf8'); } catch { process.exit(0); }
+
+  // 获取新内容
+  let newContent = '';
+  if (toolInput.content) {
+    newContent = toolInput.content;
+  } else if (toolInput.new_str) {
+    newContent = oldContent.replace(toolInput.old_str || '', toolInput.new_str);
+  } else { process.exit(0); }
+
+  // 检测状态变更
+  const changes = detectStatusChanges(oldContent, newContent);
+  if (changes.length === 0) process.exit(0);
+
+  // 加载 telemetry 事件
+  const events = loadChangeEvents(projectRoot, activeStage.change);
+
+  // 安全网 1: 无任何 test_result → post-tool 可能失败，降级为警告
+  const totalTestResults = events.filter(e => e.type === 'test_result').length;
+  const hasTddTasks = changes.some(c =>
+    c.taskType === 'red' || c.taskType === 'green' || c.taskType === 'refactor');
+  if (totalTestResults === 0 && hasTddTasks) {
+    console.log(JSON.stringify({
+      decision: 'allow',
+      message: '⚠️ [SDD TDD Rhythm Gate] 未检测到任何 test_result 遥测事件。' +
+        'sdd-post-tool.cjs 可能未正常工作。TDD 节奏检查降级为警告模式。',
+    }));
+    process.exit(0);
+  }
+
+  // G4: 批量更新检测（E1 修正：不再提前退出，模式检查继续执行）
+  var skipPerTaskCheck = false;
+  if (changes.length >= 2 && hasTddTasks) {
+    // 安全网 2: 全部有 task_update 遥测 → check-task 合法更新，跳过逐个检查
+    const allHaveTaskUpdate = changes.every(change =>
+      events.some(e => e.type === 'task_update' && e.task_id === change.taskId));
+    if (!allHaveTaskUpdate) {
+      core.blockWithReason(
+        `[SDD TDD Rhythm Gate] 检测到单次写入中 ${changes.length} 个任务状态变更，且无对应 task_update 遥测。\n\n` +
+        '⛔ 禁止批量修改任务状态。必须逐个通过 task_update → check-task 流程更新。\n' +
+        `批量变更的任务: ${changes.map(c => c.taskId).join(', ')}`);
+    }
+    // E1 修正：有 task_update → 跳过逐个证据检查，但模式检查继续执行
+    skipPerTaskCheck = true;
+  }
+
+  // 逐个检查（E1 修正：批量安全网触发时跳过逐个检查，但模式检查仍执行）
+  if (!skipPerTaskCheck) {
+    for (const change of changes) {
+      const { taskId, taskType } = change;
+
+      if (taskType === 'red') {
+        const hasRedEvidence = events.some(e =>
+          e.type === 'test_result' && e.task_id === taskId &&
+          e.result === 'failure' &&
+          e.details && e.details.test_results && e.details.test_results.tdd_phase === 'red');
+        if (!hasRedEvidence) {
+          core.blockWithReason(
+            `[SDD TDD Rhythm Gate] 任务 ${taskId} 是 RED 任务，标记完成前必须先运行测试并确认失败。\n\n` +
+            '未检测到对应的 test_result(result=failure, tdd_phase=red) 遥测事件。\n' +
+            '请先运行测试确认 RED 失败，记录 test_result 后再标记任务完成。');
+        }
+      }
+
+      if (taskType === 'green') {
+        const hasGreenEvidence = events.some(e =>
+          e.type === 'test_result' && e.task_id === taskId &&
+          e.result === 'success' &&
+          e.details && e.details.test_results && e.details.test_results.tdd_phase === 'green');
+        if (!hasGreenEvidence) {
+          core.blockWithReason(
+            `[SDD TDD Rhythm Gate] 任务 ${taskId} 是 GREEN 任务，标记完成前必须先运行测试并确认通过。\n\n` +
+            '未检测到对应的 test_result(result=success, tdd_phase=green) 遥测事件。\n' +
+            '请先运行测试确认 GREEN 通过，记录 test_result 后再标记任务完成。');
+        }
+        // G5: RED→GREEN 间隔检查
+        const pairedRedTaskId = findPairedRedTaskId(newContent, taskId);
+        if (pairedRedTaskId) {
+          const redEvent = events.find(e =>
+            e.type === 'test_result' && e.task_id === pairedRedTaskId && e.result === 'failure');
+          const greenEvent = events.find(e =>
+            e.type === 'test_result' && e.task_id === taskId && e.result === 'success');
+          if (redEvent && greenEvent) {
+            const gap = (new Date(greenEvent.timestamp).getTime() -
+              new Date(redEvent.timestamp).getTime()) / 1000;
+            if (gap < 60) {
+              core.blockWithReason(
+                `[SDD TDD Rhythm Gate] TDD 节奏异常：\n\n` +
+                `任务 ${taskId}(GREEN) 与 ${pairedRedTaskId}(RED) 的测试执行间隔仅 ${gap} 秒，建议 >60 秒。\n` +
+                '可能存在批量执行或跳过 RED 阶段的情况。');
+            }
+          }
+        }
+      }
+
+      if (taskType === 'refactor') {
+        const hasRefactorEvidence = events.some(e =>
+          e.type === 'test_result' && e.task_id === taskId &&
+          e.result === 'success' &&
+          e.details && e.details.test_results && e.details.test_results.tdd_phase === 'refactor');
+        if (!hasRefactorEvidence) {
+          core.blockWithReason(
+            `[SDD TDD Rhythm Gate] 任务 ${taskId} 是 REFACTOR 任务，` +
+            '标记完成前必须先运行测试确认全部通过（测试仍绿）。\n\n' +
+            '未检测到对应的 test_result(result=success, tdd_phase=refactor) 遥测事件。');
+        }
+      }
+
+      // 安全网 3: unknown 类型降级为警告
+      if (taskType === 'unknown') {
+        console.log(JSON.stringify({
+          decision: 'allow',
+          message: `⚠️ [SDD TDD Rhythm Gate] 任务 ${taskId} 的类型字段无法识别，已放行。` +
+            '建议补全 **类型** 字段，可选值：测试-RED | 实现-GREEN | 重构-REFACTOR | 配置 | 数据层 | 接口层 | 接口测试',
+        }));
+      }
+      // non-tdd 类型：直接放行
+    }
+  }
+
+  // ═══ E1/E2/E3: 全局 TDD 批量执行模式检测（总是执行，不受 skipPerTaskCheck 影响） ═══
+  const batchPattern = core.detectTddBatchPattern(
+    events,
+    activeStage.timestamp,
+    newContent
+  );
+
+  if (batchPattern.has_violation && batchPattern.severity === 'critical') {
+    const criticalViolations = batchPattern.violations.filter(v => v.severity === 'critical');
+    const violationMessages = criticalViolations.map(v =>
+      `【${v.type}】${v.message}`
+    ).join('\n');
+
+    // 构建恢复引导
+    const tddTaskIds = batchPattern.tdd_events
+      .map(e => e.task_id)
+      .filter((v, i, a) => a.indexOf(v) === i);
+
+    core.blockWithReason(
+      `⛔ [SDD TDD Rhythm Gate] 检测到 TDD 批量执行违规！\n\n` +
+      `违规详情：\n${violationMessages}\n\n` +
+      `涉及任务：${tddTaskIds.join(', ')}\n\n` +
+      `━━━ 恢复步骤 ━━━\n` +
+      `1. 回退相关源代码到第一个违规任务之前的状态\n` +
+      `2. 逐对重新执行 RED→GREEN 循环（每对间隔 > 60 秒）\n` +
+      `3. 每次运行测试后记录 test_result 事件\n` +
+      `4. 全部重新执行后，再次更新 tasks.md\n\n` +
+      `注意：重新执行产生的新 test_result 事件会覆盖旧的批量事件。\n` +
+      `Hook 检查每个任务的最新事件，不会卡死。\n` +
+      `━━━━━━━━━━━━`);
+  }
+
+  if (batchPattern.has_violation && batchPattern.severity === 'warning') {
+    const warningViolations = batchPattern.violations.filter(v => v.severity === 'warning');
+    const warningMessages = warningViolations.map(v =>
+      `【${v.type}】${v.message}`
+    ).join('\n');
+    console.log(JSON.stringify({
+      decision: 'allow',
+      message: `⚠️ [SDD TDD Rhythm Gate] TDD 节奏警告：\n${warningMessages}\n` +
+        '建议检查是否批量执行了测试。',
+    }));
+  }
+
+  process.exit(0);
+}
+
+module.exports = {
+  detectStatusChanges, detectTaskType, findPairedRedTaskId,
+  loadChangeEvents, readTestStrategy,
+};

package/templates/hooks/codebuddy/settings.json

@@ -39,6 +39,10 @@
           {
             "type": "command",
             "command": "node \"$CODEBUDDY_PROJECT_DIR/.codebuddy/hooks/sdd-apply-gate.cjs\""
+          },
+          {
+            "type": "command",
+            "command": "node \"$CODEBUDDY_PROJECT_DIR/.codebuddy/hooks/sdd-tdd-rhythm-gate.cjs\""
           }
         ]
       }
@@ -50,6 +54,10 @@
           {
             "type": "command",
             "command": "node \"$CODEBUDDY_PROJECT_DIR/.codebuddy/hooks/sdd-post-tool.cjs\""
+          },
+          {
+            "type": "command",
+            "command": "node \"$CODEBUDDY_PROJECT_DIR/.codebuddy/hooks/sdd-mid-checkpoint.cjs\""
           }
         ]
       }

package/templates/openspec/proposal.md

@@ -13,12 +13,16 @@ delta-state: "added"
 predecessor-version: "" # added 留空；modified/removed 指向直接前序版本
 mode: "" # full=分 Capability 产物，simple=根目录精简产物
 test-strategy: "" # tdd=测试先行, impl-first=实现优先, none=无测试
-# 外部需求键（默认必填 ≥1 个合规 REQ；探索性/纯内部重构可走 numbering-waiver）
+change-type: "" # config | transaction | report | composite | unknown，由 Agent 自动分类
+change-type-source: "agent-inferred"
+change-type-confidence: "" # high | medium | low
+change-type-reason: "" # 一句中文分类理由
+# 外部需求键（默认必填 ≥1 个；编号格式：大写字母+数字+连字符+下划线，例 KLERP-001、REQ-FI-2024-001；探索性/纯内部重构可走 numbering-waiver）
 requirement-refs:
   - system: requirement-mgmt
     object-type: requirement
-    external-id: REQ-<DOMAIN>-<YEAR>-<SEQ>   # 例 REQ-FI-2024-001
-    feature-id: FEAT-<DOMAIN>-<SEQ>          # 可选，需求所属功能（需求系统权威）
+    external-id: "<外部需求编号>"   # 例 KLERP-001, REQ-FI-2024-001, 1010000
+    feature-id: "<外部功能编号>"    # 可选，需求所属功能（例 FEAT-FI-012, KLERP_F-001）
 # numbering-waiver:
 #   reason: "探索性原型，本轮不种桥"
 # Continuity：字段一律来自知识库 resolve，禁止本地 archive 文件夹名