kld-sdd 2.4.19 → 2.5.1

package/templates/commands/kunlunzhima/skill-bridge.md

@@ -0,0 +1,23 @@
+---
+name: "${BRIDGE_NAME}"
+description: "${BRIDGE_DESCRIPTION}"
+argument-hint: "${BRIDGE_ARGUMENT_HINT}"
+---
+
+# SDD KunlunZhima Skill Bridge
+
+本命令是 KunlunZhima IDE 的 SDD Skill 桥接入口，不包含 Skill 的具体执行步骤。
+
+## Skill 路径
+
+请**完整读取并严格遵循**以下 Skill 文件：
+
+`${SKILL_RELATIVE_PATH}`
+
+## 用户输入
+
+将本命令后的用户输入作为 Skill 的输入参数传递。
+
+## 相对引用
+
+Skill 正文中的相对路径引用均以 Skill 所在目录（`${SKILL_DIR}`）解析。

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

@@ -215,10 +215,17 @@ function block(decision, reason, extra) {
   process.exit(2);
 }
 
-function recordWarning(projectRoot, applyEvent, code, message) {
+function recordWarning(projectRoot, applyEvent, code, message, taskIds) {
   const logPath = path.join(projectRoot, 'skywalk-sdd', 'log.cjs');
-  if (!fs.existsSync(logPath)) return;
+  if (!fs.existsSync(logPath)) {
+    // Y8 修复：log.cjs 缺失时 stderr 提示（本 repo 无 log.cjs 属预期——脚手架部署时 deployTelemetryDataDir 复制 index.cjs→log.cjs）
+    try { console.error(`[sdd-apply-test-gate] log.cjs 不存在（${logPath}），telemetry_warning 未记录；确认 deployTelemetryDataDir 已执行`); } catch {}
+    return;
+  }
   try {
+    // T1.5b(v3): task_update_reuse 写入复用 task_ids，供 E4(A3) 扣分识别
+    const details = { warning: code, test_strategy: applyEvent.test_strategy };
+    if (Array.isArray(taskIds) && taskIds.length > 0) details.task_ids = taskIds;
     const args = [
       logPath,
       'record',
@@ -230,7 +237,7 @@ function recordWarning(projectRoot, applyEvent, code, message) {
       '--source=claude-hook',
       '--result=partial',
       `--summary=${message}`,
-      `--details-json=${JSON.stringify({ warning: code, test_strategy: applyEvent.test_strategy })}`,
+      `--details-json=${JSON.stringify(details)}`,
     ];
     if (applyEvent.capability) args.push(`--capability=${applyEvent.capability}`);
     if (applyEvent.session_id) args.push(`--session-id=${applyEvent.session_id}`);
@@ -280,36 +287,176 @@ function shouldGate(projectRoot, applyEvent) {
   return { strategy, changeName: applyEvent.change, capability: applyEvent.capability };
 }
 
-// ── 主逻辑 ─────────────────────────────────────────────
-
-const input = parseInput(readStdin());
-const projectRoot = getProjectRoot(input);
-const toolName = String(input.tool_name || input.toolName || '');
-const toolInput = input.tool_input || input.toolInput || {};
-const command = String(toolInput.command || '');
-
-const activeApply = findActiveApplyStage(projectRoot);
-if (!activeApply) {
-  process.exit(0);
+// ── T1.1: task_update 复用检测（不阻断，仅记 warning） ──
+/**
+ * 检测同一 change 的 implementation task_update 是否复用同一次测试结果。
+ * 判定：同 session_id + 同 test_results 三元组(passed+failed+duration_ms) 的 group 内 >1 条（不再要求时间戳相邻）。
+ * 测试确实跑过，只是 task_update 记录不实 → 记 telemetry_warning(task_update_reuse)，不阻断。
+ * 返回 { reused, groups: [{ duration_ms, fingerprint, session_id, task_ids }] }
+ */
+function detectReusedTestResults(events) {
+  const taskUpdates = (events || []).filter((e) =>
+    e && e.type === 'task_update' &&
+    e.details && e.details.test_results &&
+    isRealTestDetails(e.details.test_results)
+  );
+  const bySession = new Map();
+  for (const e of taskUpdates) {
+    const sid = e.session_id || '_no_session_';
+    if (!bySession.has(sid)) bySession.set(sid, []);
+    bySession.get(sid).push(e);
+  }
+  const groups = [];
+  let reused = false;
+  for (const [, group] of bySession) {
+    const byFingerprint = new Map();
+    for (const e of group) {
+      const tr = e.details.test_results;
+      const passed = Number(tr.passed);
+      const failed = Number(tr.failed);
+      const dur = Number(tr.duration_ms);
+      if (!Number.isFinite(dur)) continue;
+      const fp = `${passed}|${failed}|${dur}`;
+      if (!byFingerprint.has(fp)) byFingerprint.set(fp, []);
+      byFingerprint.get(fp).push(e);
+    }
+    for (const [fp, evs] of byFingerprint) {
+      if (evs.length < 2) continue;
+      const sorted = evs.slice().sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0));
+      // T1.5(v3): 去掉 <5s 相邻限制 — 同 session + 同三元组即复用，无论时间间隔
+      // todo-cli 真实场景：实现任务与验证任务间隔 15-17s，<5s 阈值漏检 3/4 组
+      reused = true;
+      const first = sorted[0];
+      groups.push({
+        duration_ms: Number(first.details.test_results.duration_ms),
+        fingerprint: fp,
+        session_id: first.session_id || null,
+        task_ids: sorted.map((e) => e.task_id || e.event_id).filter(Boolean),
+      });
+    }
+  }
+  return { reused, groups };
 }
 
-const bashGate = toolName === 'Bash' && isApplyCompletionBash(command);
-const stopGate = !toolName || toolName === 'Stop';
+/** T1.6: 检测本阶段是否有失败/门禁拦截但无 process_note 过程记录。
+ *  Y4 修复：when 参数过滤时间窗口（仅检测 sinceTimestamp 后的事件），避免 change 级误报。
+ *  返回 { gap, hasFailure, hasGateBlock, hasProcessNote } */
+function detectProcessNoteGap(events, sinceTimestamp) {
+  const evs = events || [];
+  const filtered = sinceTimestamp ? evs.filter(e => new Date(e.timestamp || 0).getTime() >= new Date(sinceTimestamp).getTime()) : evs;
+  const stageEnds = filtered.filter((e) => e.type === 'stage_end');
+  const hasFailure = stageEnds.some((e) => e.result === 'failure' || e.result === 'partial');
+  const hasGateBlock = filtered.some((e) =>
+    e.type === 'telemetry_warning' && e.details && e.details.warning === 'apply_test_missing'
+  );
+  const hasProcessNote = filtered.some((e) => e.type === 'process_note');
+  const gap = (hasFailure || hasGateBlock) && !hasProcessNote;
+  return { gap, hasFailure, hasGateBlock, hasProcessNote };
+}
 
-if (!bashGate && !stopGate) {
-  process.exit(0);
+/** B2(v3): 检测 tdd 策略下 apply 阶段是否缺失"红灯"（失败的测试结果）。
+ *  TDD 节奏要求测试骨架先 RED（failed>0）再实现转 GREEN；若 apply 阶段有真实测试信号
+ *  但全部 failed===0，说明骨架可能未经 RED 验证即标记完成 → 记 telemetry_warning(tdd_red_missing)，不阻断。
+ *  不复用 isRealTestDetails（其要求 command 非空，会漏掉无 command 的骨架 test_results）。
+ *  返回 { missing, hasRed, signalCount } */
+function detectMissingTddRed(events, sinceTimestamp) {
+  const evs = events || [];
+  const filtered = sinceTimestamp ? evs.filter(e => new Date(e.timestamp || 0).getTime() >= new Date(sinceTimestamp).getTime()) : evs;
+  let signalCount = 0;
+  let hasRed = false;
+  for (const e of filtered) {
+    const tr = e && e.details && (e.details.test_results || e.details.test);
+    if (!tr || typeof tr !== 'object') continue;
+    const passed = Number(tr.passed);
+    const failed = Number(tr.failed);
+    const dur = Number(tr.duration_ms);
+    const isReal = (Number.isFinite(passed) && passed > 0)
+      || (Number.isFinite(failed) && failed > 0)
+      || (Number.isFinite(dur) && dur > 0);
+    if (!isReal) continue;
+    signalCount++;
+    if (Number.isFinite(failed) && failed > 0) hasRed = true;
+  }
+  if (signalCount === 0) return { missing: false, hasRed: false, signalCount: 0, reason: 'no-real-test-signals' };
+  return { missing: !hasRed, hasRed, signalCount };
 }
 
-const gate = shouldGate(projectRoot, activeApply);
-if (!gate) {
-  process.exit(0);
+/** 是否已存在某 code 的 telemetry_warning（去重，避免每次 hook 触发都重复记录） */
+function hasExistingWarning(events, code) {
+  return (events || []).some((e) =>
+    e.type === 'telemetry_warning' && e.details && e.details.warning === code
+  );
 }
 
-const reason = buildReason(gate.strategy, gate.changeName, gate.capability);
-recordWarning(projectRoot, { ...activeApply, test_strategy: gate.strategy }, 'apply_test_missing', 'Apply test gate blocked: no unit test evidence');
+// ── 主逻辑（仅直接执行时运行；被 require 时跳过，便于单元测试） ──
+if (require.main === module) {
+  const input = parseInput(readStdin());
+  const projectRoot = getProjectRoot(input);
+  const toolName = String(input.tool_name || input.toolName || '');
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || '');
+
+  const activeApply = findActiveApplyStage(projectRoot);
+  if (!activeApply) {
+    process.exit(0);
+  }
+
+  const bashGate = toolName === 'Bash' && isApplyCompletionBash(command);
+  const stopGate = !toolName || toolName === 'Stop';
+
+  if (!bashGate && !stopGate) {
+    process.exit(0);
+  }
+
+  // 非阻断警告检测（T1.1 task_update 复用 / T1.6 process_note 缺失）：放行但记录 warning
+  try {
+    const warningEvents = loadChangeEvents(projectRoot, activeApply.change);
+    const warningCtx = { ...activeApply, test_strategy: readTestStrategy(projectRoot, activeApply.change) };
+    const reuse = detectReusedTestResults(warningEvents);
+    if (reuse.reused && !hasExistingWarning(warningEvents, 'task_update_reuse')) {
+      const taskCount = reuse.groups.reduce((s, g) => s + g.task_ids.length, 0);
+      const reusedTaskIds = reuse.groups.flatMap((g) => g.task_ids).filter(Boolean);
+      recordWarning(projectRoot, warningCtx, 'task_update_reuse',
+        `检测到 ${reuse.groups.length} 组 task_update 复用同一次测试结果（共 ${taskCount} 条），测试确实跑过但记录不实`,
+        reusedTaskIds);
+    }
+    const noteGap = detectProcessNoteGap(warningEvents, activeApply.timestamp);
+    if (noteGap.gap && !hasExistingWarning(warningEvents, 'process_note_missing')) {
+      recordWarning(projectRoot, warningCtx, 'process_note_missing',
+        '本阶段存在失败/门禁拦截但无 process_note 过程记录，建议补记');
+    }
+    // B2(v3): tdd 策略下 apply 阶段无红灯（失败 test_result）→ 软警告，不阻断
+    if (warningCtx.test_strategy === 'tdd') {
+      const redGap = detectMissingTddRed(warningEvents, activeApply.timestamp);
+      if (redGap.missing && !hasExistingWarning(warningEvents, 'tdd_red_missing')) {
+        recordWarning(projectRoot, warningCtx, 'tdd_red_missing',
+          'tdd 策略下 apply 阶段未检测到失败的测试结果（红灯），测试骨架可能未经 RED 验证即标记完成');
+      }
+    }
+  } catch {
+    // 警告检测失败不阻断主流程
+  }
+
+  const gate = shouldGate(projectRoot, activeApply);
+  if (!gate) {
+    process.exit(0);
+  }
+
+  const reason = buildReason(gate.strategy, gate.changeName, gate.capability);
+  recordWarning(projectRoot, { ...activeApply, test_strategy: gate.strategy }, 'apply_test_missing', 'Apply test gate blocked: no unit test evidence');
+
+  block('block', reason, {
+    test_strategy: gate.strategy,
+    change: gate.changeName,
+    capability: gate.capability,
+  });
+}
 
-block('block', reason, {
-  test_strategy: gate.strategy,
-  change: gate.changeName,
-  capability: gate.capability,
-});
+module.exports = {
+  detectReusedTestResults,
+  detectProcessNoteGap,
+  detectMissingTddRed,
+  hasExistingWarning,
+  isRealTestDetails,
+  requiresUnitTests,
+};

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

@@ -70,15 +70,23 @@ function latestActiveStage(projectRoot) {
     .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime())[0] || null;
 }
 
+// inferResult：解析 tool_response 判定构建/测试结果
+// 返回 { result: 'success'|'failure'|'partial', exit_code_known: boolean }
+// v2.5 契约变更：返回类型从 string 变为对象（含 exit_code_known 标注）；旧调用方 `inferResult(input) === 'success'` 需改为 `.result === 'success'`
 function inferResult(input) {
   const response = input.tool_response || input.toolResponse || {};
-  if (typeof response.exit_code === 'number') return response.exit_code === 0 ? 'success' : 'failure';
-  if (typeof response.exitCode === 'number') return response.exitCode === 0 ? 'success' : 'failure';
-  if (typeof response.success === 'boolean') return response.success ? 'success' : 'failure';
-  return 'partial';
+  if (typeof response.exit_code === 'number') return { result: response.exit_code === 0 ? 'success' : 'failure', exit_code_known: true };
+  if (typeof response.exitCode === 'number') return { result: response.exitCode === 0 ? 'success' : 'failure', exit_code_known: true };
+  if (typeof response.success === 'boolean') return { result: response.success ? 'success' : 'failure', exit_code_known: true };
+  // fallback：从 stdout/stderr 识别构建失败信号；无法判定时 partial 且 exit_code_known=false
+  const out = String(response.stdout || response.stderr || '');
+  if (/BUILD FAILED|error TS\d+|ERR_/i.test(out)) return { result: 'failure', exit_code_known: false };
+  return { result: 'partial', exit_code_known: false };
 }
 
 function inferRecord(command) {
+  // 排除 telemetry 自身的 record 命令（防止 log.cjs/log.js record 被误判为 build/test 结果）
+  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)) {
     return {
       type: 'test_result',
@@ -96,23 +104,29 @@ function inferRecord(command) {
   return null;
 }
 
-function recordTelemetry(projectRoot, activeStage, record, result) {
+function recordTelemetry(projectRoot, activeStage, record, result, exitCodeKnown, input, runner) {
   const logPath = path.join(projectRoot, 'skywalk-sdd', 'log.cjs');
   const legacyLogPath = path.join(projectRoot, 'skywalk-sdd', 'log.js');
   const logCli = fs.existsSync(logPath) ? logPath : legacyLogPath;
   if (!fs.existsSync(logCli)) return;
 
+  const toolInput = (input && (input.tool_input || input.toolInput)) || {};
+  const toolResponse = (input && (input.tool_response || input.toolResponse)) || {};
   const details = { [record.detailsKey]: { ...record.details } };
   if (record.type === 'build_result') {
     details.build_results.success = result === 'success';
     details.build_results.error_count = result === 'success' ? 0 : null;
+    details.build_results.exit_code_known = Boolean(exitCodeKnown);
+    const durationMs = typeof toolResponse.duration_ms === 'number' ? toolResponse.duration_ms : null;
+    details.build_results.duration_ms = durationMs;
+    details.build_results.duration_known = durationMs !== null;
   }
 
   const args = [
     logCli,
     'record',
     `--type=${record.type}`,
-    `--command=${activeStage.command || activeStage.stage || 'unknown'}`,
+    `--command=${toolInput.command || activeStage.command || activeStage.stage || 'unknown'}`,
     `--project=${projectRoot}`,
     `--change=${activeStage.change || 'general'}`,
     `--agent=${activeStage.agent_type || 'claude-code'}`,
@@ -124,23 +138,30 @@ function recordTelemetry(projectRoot, activeStage, record, result) {
   if (activeStage.capability) args.push(`--capability=${activeStage.capability}`);
   if (activeStage.task_id) args.push(`--task-id=${activeStage.task_id}`);
   if (activeStage.session_id) args.push(`--session-id=${activeStage.session_id}`);
-  execFileSync('node', args, { cwd: projectRoot, stdio: 'ignore' });
+  const run = runner || ((a) => execFileSync('node', a, { cwd: projectRoot, stdio: 'ignore' }));
+  run(args);
 }
 
-const input = parseInput(readStdin());
-const toolInput = input.tool_input || input.toolInput || {};
-const command = String(toolInput.command || input.command || '');
-const record = inferRecord(command);
-if (!record) process.exit(0);
+// 仅在直接执行时跑主流程；require 时不读 stdin（便于单元测试）
+if (require.main === module) {
+  const input = parseInput(readStdin());
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || input.command || '');
+  const record = inferRecord(command);
+  if (!record) process.exit(0);
 
-const projectRoot = findProjectRoot(input);
-const activeStage = latestActiveStage(projectRoot);
-if (!activeStage || !activeStage.change || activeStage.change === 'general') {
-  process.exit(0);
-}
+  const projectRoot = findProjectRoot(input);
+  const activeStage = latestActiveStage(projectRoot);
+  if (!activeStage || !activeStage.change || activeStage.change === 'general') {
+    process.exit(0);
+  }
 
-try {
-  recordTelemetry(projectRoot, activeStage, record, inferResult(input));
-} catch {
-  process.exit(0);
+  try {
+    const inferred = inferResult(input);
+    recordTelemetry(projectRoot, activeStage, record, inferred.result, inferred.exit_code_known, input);
+  } catch {
+    process.exit(0);
+  }
 }
+
+module.exports = { inferResult, inferRecord, recordTelemetry, findProjectRoot, latestActiveStage };

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

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+'use strict';
+
+const core = require('./hook-gate-core.cjs');
+
+const parsed = core.parseHookInput(core.readStdin(), { strict: true });
+if (!parsed.ok) {
+  core.blockWithReason(parsed.error);
+}
+
+const input = core.normalizeHookInput(parsed.input);
+const result = core.evaluateApplyWriteGate(input, 'codebuddy');
+if (result.action === 'block') {
+  core.blockWithReason(result.reason);
+}
+core.allowExit();